public void CreatedPlugCanBeDisconnected()
 {
     var stream = Substitute.For<IAudioStream>();
     var plug = new Plug<IAudioStream>(stream);
     plug.Disconnect();
     plug.IsConnected.Should().Be.False();
 }

 public ConnectorCollection CreateConnectorCollection()
 {
   var plug = new Plug();
   var connectorCollection = new ConnectorCollection();
   connectorCollection.Connectors.Add(plug);
   return connectorCollection;
 }

        public void RemoveHalfPlug(Plug plug) {
            try {
                plugs.Remove(plug);
                Plugs_ListBox.ItemsSource = plugs;
            } catch (Exception) {

            }
        }

        public void CanConnectPlugToSocket()
        {
            var stream = Substitute.For<IAudioStream>();
            var plug = new Plug<IAudioStream>(stream);
            var socket = new Socket<IAudioStream>();

            plug.ConnectTo(socket).Should().Be.True();
        }

        public void CanConnectSocketToPlug()
        {
            var stream = Substitute.For<IAudioStream>();
            var plug = new Plug<IAudioStream>(stream);
            var socket = new Socket<IAudioStream>();

            socket.ConnectTo(plug).Should().Be.True();
        }

        public void ConnectingSetsSocketChannel()
        {
            var stream = Substitute.For<IAudioStream>();
            var plug = new Plug<IAudioStream>(stream);
            var socket = new Socket<IAudioStream>();

            plug.ConnectTo(socket);
            Assert.Same(stream, socket.Channel);
        }

        public void ConnectedSocketIsConnected()
        {
            var stream = Substitute.For<IAudioStream>();
            var plug = new Plug<IAudioStream>(stream);
            var socket = new Socket<IAudioStream>();

            plug.ConnectTo(socket);
            socket.IsConnected.Should().Be.True();
        }

 //--- Methods ---
 protected override Yield Start(XDoc config, Result result)
 {
     yield return Coroutine.Invoke(base.Start, config, new Result());
     _redirect = Plug.New(config["proxy"].AsUri ?? config["redirect"].AsUri, TimeSpan.FromSeconds(config["timeout"].AsInt ?? (int)Plug.DEFAULT_TIMEOUT.TotalSeconds));
     if(_redirect == null) {
         throw new ArgumentException("redirect URI missing or invalid");
     }
     result.Return();
 }

 //--- Constructors ---
 /// <summary>
 /// Create new client instance 
 /// </summary>
 /// <param name="config">Client configuration.</param>
 /// <param name="timerFactory">Timer factory.</param>
 public AmazonS3Client(AmazonS3ClientConfig config, TaskTimerFactory timerFactory)
 {
     _config = config;
     _bucketPlug = Plug.New(_config.S3BaseUri)
         .WithS3Authentication(_config.PrivateKey, _config.PublicKey)
         .WithTimeout(_config.Timeout)
         .At(_config.Bucket);
     _rootPlug = _bucketPlug;
     if(!string.IsNullOrEmpty(_config.RootPath)) {
         _keyRootParts = _config.RootPath.Split(new[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
         if(_keyRootParts != null && _keyRootParts.Any()) {
             _rootPlug = _rootPlug.At(_keyRootParts);
         }
     }
     _expirationEntries = new ExpiringHashSet<string>(timerFactory);
     _expirationEntries.EntryExpired += OnDelete;
 }

    public static void Main(string[] args)
    {
        if (args.Length != 2) {
        Console.WriteLine("Need socket id and file-name as an argument.");
        return;
        }
        uint socket_id = UInt32.Parse(args[0]);
        string filename=args[1];
        Console.WriteLine("filename="+filename);

        Console.WriteLine("using socket "+socket_id);

        //	    Glib.Thread.Init();
        Gdk.Threads.Init();

        Application.Init();
        Gdk.Threads.Enter();
        try {

        Plug plug= new Plug(socket_id);

        Fixed fixed1 = new Fixed();
        fixed1.Put(new Label("File: \""+filename+"\""), 10, 10);
        fixed1.Put(new Entry("HELLO"), 10, 50);
        fixed1.Put(new Entry("World"), 10, 100);
        fixed1.ShowAll();
        plug.Add(fixed1);
        plug.ShowAll();

        Console.WriteLine("app is running..");
        Application.Run();
            } finally {
          Gdk.Threads.Leave();
            }
        Console.WriteLine("Done!");
    }

 private bool WaitFor(Plug plug, Func<DreamMessage, bool> func, TimeSpan timeout)
 {
     var expire = DateTime.Now.Add(timeout);
     while(expire > DateTime.Now) {
         var r = plug.GetAsync().Wait();
         if(func(r)) {
             return true;
         }
         Thread.Sleep(100);
     }
     return false;
 }

 public void Init()
 {
     _hostInfo = DreamTestHelper.CreateRandomPortHost();
     _hostInfo.Host.Self.At("load").With("name", "test.mindtouch.dream").Post(DreamMessage.Ok());
     var config = new XDoc("config")
        .Elem("path", "test")
        .Elem("sid", "sid://mindtouch.com/DreamContextTestService");
     DreamMessage result = _hostInfo.LocalHost.At("host", "services").With("apikey", _hostInfo.ApiKey).PostAsync(config).Wait();
     Assert.IsTrue(result.IsSuccessful, result.ToText());
     _plug = Plug.New(_hostInfo.LocalHost.Uri.WithoutQuery()).At("test");
     DreamContextTestService.ContextVar = null;
 }

 public Yield CreateBadStartChild(DreamContext context, DreamMessage request, Result<DreamMessage> response)
 {
     yield return CreateService(
         "badchild",
         "sid://mindtouch.com/TestBadStartService",
         new XDoc("config").Elem("throw", context.GetParam("throw", "false")),
         new Result<Plug>()).Set(v => _badChild = v);
     response.Return(DreamMessage.Ok());
     yield break;
 }

 Yield IPlugEndpoint.Invoke(Plug plug, string verb, XUri uri, DreamMessage request, Result<DreamMessage> response)
 {
     _env.UpdateInfoMessage(_sourceInternal, null);
     Result<DreamMessage> res = new Result<DreamMessage>(response.Timeout);
     _env.SubmitRequestAsync(verb, uri, null, request, res);
     yield return res;
     response.Return(res);
 }

 private void CreateSecondPrivateStorageServiceProxy()
 {
     _hostInfo.Host.Self.At("services").Post(
         new XDoc("config")
             .Elem("class", typeof(TestServiceWithPrivateStorage).FullName)
             .Elem("path", TEST_PATH + "2"));
     _log.Debug("created second storage service");
     testService = Plug.New(_hostInfo.Host.LocalMachineUri).At(TEST_PATH + "2");
 }

 public void Send(Plug jack, float[] values)
 {
     m_incomingJackValues[jack] = values;
     SetDirty();
 }

 //--- Methods ---
 protected override Yield Start(XDoc config, Result result)
 {
     yield return Coroutine.Invoke(base.Start, config, new Result());
     yield return CreateService("inner", "http://services.mindtouch.com/dream/test/2007/03/sample-inner", new XDoc("config").Start("prologue").Attr("name", "dummy").Value("p3").End().Start("epilogue").Attr("name", "dummy").Value("e3").End(), new Result<Plug>()).Set(v => _inner = v);
     result.Return();
 }

 private void AssertFeature(string pattern, Plug plug)
 {
     AssertFeature(pattern, plug, null);
 }

 public void Init()
 {
     _hostInfo = DreamTestHelper.CreateRandomPortHost();
     _hostInfo.Host.Self.At("load").With("name", "test.mindtouch.dream").Post(DreamMessage.Ok());
     var config = new XDoc("config")
        .Elem("path", "test")
        .Elem("sid", "http://services.mindtouch.com/dream/test/2010/07/featuretestserver");
     DreamMessage result = _hostInfo.LocalHost.At("host", "services").With("apikey", _hostInfo.ApiKey).PostAsync(config).Wait();
     Assert.IsTrue(result.IsSuccessful, result.ToText());
     _plug = Plug.New(_hostInfo.LocalHost.Uri.WithoutQuery()).At("test");
     _blueprint = _plug.At("@blueprint").Get().ToDocument();
 }

 public void Init()
 {
     var builder = new ContainerBuilder();
     builder.RegisterType<Foo>().As<IFoo>().RequestScoped();
     _hostInfo = DreamTestHelper.CreateRandomPortHost(new XDoc("config"), builder.Build(ContainerBuildOptions.None));
     _hostInfo.Host.Self.At("load").With("name", "test.mindtouch.dream").Post(DreamMessage.Ok());
     var config = new XDoc("config")
        .Elem("path", "test")
        .Elem("sid", "http://services.mindtouch.com/dream/test/2010/07/featuretestserver");
     DreamMessage result = _hostInfo.LocalHost.At("host", "services").With("apikey", _hostInfo.ApiKey).Post(config, new Result<DreamMessage>()).Wait();
     Assert.IsTrue(result.IsSuccessful, result.ToText());
     _plug = Plug.New(_hostInfo.LocalHost.Uri.WithoutQuery()).At("test");
     _blueprint = _plug.At("@blueprint").Get().ToDocument();
 }