/// <summary>
        /// Constructor used for unit testing
        /// </summary>
        /// <param name="runtime">IRuntime object to provide the data to the camera</param>
        internal IavaCamera(IRuntime runtime)
        {
            // Set the IRuntime object
            _runtime = runtime;

            InitializeDevice();
        }

        private static void SetMessageValuesIfNotSetInClient(RequestHeader message, IRuntime runtime)
        {
            if (runtime == null) return;
            if (message.MessageId.IsNullOrWhiteSpace())
                message.MessageId = Guid.NewGuid().ToString();
            if (message.Environment.IsNullOrWhiteSpace())
                message.Environment = runtime.Environment;
            if (message.ServiceName.IsNullOrWhiteSpace())
                message.ServiceName = runtime.ServiceName;
            if (message.ConfigSet.IsNullOrWhiteSpace())
                message.ConfigSet = Utilities.GetConfigSetName();
            if (message.TimeStamp == null)
                message.TimeStamp = DateTime.UtcNow;
            if (runtime.RequestContext.IsInstance() && runtime.RequestContext.RequestHeader.IsInstance())
            {
                message.ReferingMessageId = runtime.RequestContext.RequestHeader.MessageId;

            }
            string supportCode;
            if (runtime.TryGetSupportCode(out supportCode)) message.SupportCode = supportCode;
            else
            {
                if (runtime.RequestContext.IsInstance() && runtime.RequestContext.RequestHeader.IsInstance())
                {
                    message.SupportCode = runtime.RequestContext.RequestHeader.SupportCode;
                }
            }
        }

        /// <summary>
        /// Initializes the isolation provider.
        /// </summary>
        /// <param name="runtime">The runtime.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="runtime"/> is null.</exception>
        public PartCoverTestIsolationProvider(IRuntime runtime)
        {
            if (runtime == null)
                throw new ArgumentNullException("runtime");

            this.runtime = runtime;
        }

 private static void ReportPrimes(IRuntime runtime, List<int> primes, int n, int client)
 {
     // item 229
     string[] primesAsText = primes
     .Select(p => p.ToString())
     .ToArray();
     // item 226
     string primeString = String.Join(
     "\n",
     primesAsText
     );
     // item 227
     string result = String.Format(
     "Prime numbers up to {0}: {1} found:\n{2}",
     n,
     primes.Count,
     primeString
     );
     // item 228
     runtime.SendMessage(
     client,
     CallResult.Completed,
     result,
     0
     );
 }

 private static void DownloadCompleted(IRuntime runtime, int caller, DownloadDataCompletedEventArgs e)
 {
     // item 255
     if (e.Cancelled) {
     // item 258
     runtime.SendMessage(
         caller,
         Cancel,
         null,
         0
     );
     } else {
     // item 259
     if (e.Error == null) {
         // item 262
         runtime.SendMessage(
             caller,
             CallResult.Completed,
             e.Result,
             0
         );
     } else {
         // item 261
         runtime.SendMessage(
             caller,
             CallResult.Error,
             e.Error,
             0
         );
     }
     }
 }

        /// <summary>
        /// Creates a host factory.
        /// </summary>
        /// <param name="runtime">The runtime.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="runtime"/> is null.</exception>
        public IsolatedProcessHostFactory(IRuntime runtime)
        {
            if (runtime == null)
                throw new ArgumentNullException("runtime");

            runtimePath = runtime.GetRuntimeSetup().RuntimePath;
        }

 public ExternalThread(string name, IRuntime runtime, IActorLogger logger, IErrorHandler errorHandler, Action<Action> dispatchMethod)
 {
     _name = name;
     _runtime = runtime;
     _logger = logger;
     _errorHandler = errorHandler;
     _dispatcher = dispatchMethod;
 }

        /// <summary>
        /// Initializes the isolation provider.
        /// </summary>
        /// <param name="runtime">The runtime.</param>
        /// <param name="version">The NCover version.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="runtime"/> is null.</exception>
        public NCoverTestIsolationProvider(IRuntime runtime, NCoverVersion version)
        {
            if (runtime == null)
                throw new ArgumentNullException("runtime");

            this.runtime = runtime;
            this.version = version;
        }

        public static LazyDownloadArgs CreateSeleniumArgs(IRuntime runtime, int line, int threadCount, string cssElement, int cssTimeout, Table<ResultRow> table)
        {
            var args = new LazyDownloadArgs(runtime, threadCount);
            foreach (var row in table)
                args.Wires.Add(new SeleniumHttpWire(row[0].ToString(), cssElement, cssTimeout, runtime, line));

            return args;
        }

        public static LazyDownloadArgs CreateWebRequestArgs(IRuntime runtime, int line, int threadCount, Table<ResultRow> table)
        {
            var args = new LazyDownloadArgs(runtime, threadCount);
            foreach (var row in table)
                args.Wires.Add(new WebRequestHttpWire(row[0].ToString(), runtime, line));

            return args;
        }

 public static void Deactivate(IRuntime runtime)
 {
     lock (_currentLock)
     {
         _active.ContainsKey(Thread.CurrentThread).AssertTrue();
         ReferenceEquals(_active[Thread.CurrentThread], runtime).AssertTrue();
         _active.Remove(Thread.CurrentThread);
     }
 }

 public DedicatedThread(string name, IRuntime runtime, IActorLogger logger, IErrorHandler errorHandler, int actorId, IActor actor)
 {
     _actor = actor;
     _actorId = actorId;
     _name = name;
     _runtime = runtime;
     _logger = logger;
     _errorHandler = errorHandler;
 }

        public static RuntimeTable<DownloadImage> DownloadImage(IRuntime runtime, string url, int line)
        {
            var table = new RuntimeTable<DownloadImage>();

            var image = GetImage(runtime.RequestFactory, new WebRequestHttpWire(url, runtime, line));

            table.Add(image);
            return table;
        }

 public static IDisposable Activate(IRuntime runtime)
 {
     lock (_currentLock)
     {
         _active.ContainsKey(Thread.CurrentThread).AssertFalse();
         _active.ContainsValue(runtime).AssertFalse();
         _active.Add(Thread.CurrentThread, runtime);
         return new DisposableAction(() => Deactivate(runtime));
     }
 }

        private static RuntimeTable<DownloadPage> DownloadPage(IRuntime runtime, IHttpWire[] wires)
        {
            var table = new RuntimeTable<DownloadPage>();
            foreach (var wire in wires)
            {
                int contentlength;
                var doc = GetDocument(runtime.RequestFactory, wire, out contentlength);
                table.Add(new DownloadPage() { url = wire.Url, nodes = new[] { doc.DocumentNode }, date = DateTime.Now, size = contentlength });
            }

            return table;
        }

 public InstallCommand(IRuntime runtime, IFileSystem fileSystem, ICakeEnvironment environment,
     ICakeLog log, INuGetPackageConfigurationCreator packageConfigCreator,
     IFileCopier fileCopier, IHttpDownloader downloader, IGitIgnorePatcher gitIgnorePatcher)
 {
     _runtime = runtime;
     _fileSystem = fileSystem;
     _environment = environment;
     _log = log;
     _packageConfigCreator = packageConfigCreator;
     _fileCopier = fileCopier;
     _downloader = downloader;
     _gitIgnorePatcher = gitIgnorePatcher;
 }

        public static bool TryGetSupportCode(IRuntime runtime, out string supportCode)
        {
            if (runtime == null || runtime.GetStateStorageContainer() == null)
            {
                supportCode = null;
                return false;
            }
            StateStorageItem item;
            var result = runtime.GetStateStorageContainer().TryGetItem("supportCode", out item);
            if (item != null && item.Value != null) supportCode = (string)item.Value;
            else supportCode = null;
            return result;

        }

 private static void SetMessageValuesIfNotSetInClient(IRequestBase message, IRuntime runtime)
 {
     if (message.MessageId.IsNullOrWhiteSpace())
         message.MessageId = Guid.NewGuid().ToString();
     if (message.Environment.IsNullOrWhiteSpace())
         message.Environment = runtime.Environment;
     if (message.ServiceName.IsNullOrWhiteSpace())
         message.ServiceName = runtime.ServiceName;
     if (message.ConfigSet.IsNullOrWhiteSpace())
         message.ConfigSet = ConfigurationManagerHelper.GetValueOnKey("configSet");
     if (message.TimeStamp == null)
         message.TimeStamp = DateTime.UtcNow;
     if (runtime.RequestContext.IsInstance())
         message.ReferingMessageId = runtime.RequestContext.MessageId;
 }

        private static LanguageGenerator GetGenerator(string language, string knockoutPrefix, IRuntime runtime)
        {
            switch (language)
                {
                    case TypeScriptGenerator.Id:
                        return new TypeScriptGenerator();

                    case KnockoutMappingGenerator.Id:
                        return new KnockoutMappingGenerator(knockoutPrefix);

                    default:
                        runtime.Error("Unknown language: {0}", language);
                        System.Environment.Exit(-1);
                        return (LanguageGenerator)null;
            }
        }

		// --- constructors ---
		internal NetPlugin(string pluginFile, string trainFolder, IRuntime api, TrainManager.Train train) {
			base.PluginTitle = System.IO.Path.GetFileName(pluginFile);
			base.PluginValid = true;
			base.PluginMessage = null;
			base.Train = train;
			base.Panel = null;
			base.SupportsAI = false;
			base.LastTime = 0.0;
			base.LastReverser = -2;
			base.LastPowerNotch = -1;
			base.LastBrakeNotch = -1;
			base.LastAspects = new int[] { };
			base.LastSection = -1;
			base.LastException = null;
			this.PluginFolder = System.IO.Path.GetDirectoryName(pluginFile);
			this.TrainFolder = trainFolder;
			this.Api = api;
			this.SoundHandles = new SoundHandleEx[16];
			this.SoundHandlesCount = 0;
		}