public void IsDisconnected_should_return_true_when_not_connected()
 {
     using (var subscriber = new Subscriber())
     {
         Assert.IsTrue(subscriber.IsDisconnected);
     }
 }

        public ActionResult Edit(Subscriber subscriber)
        {
            //Edicao feita diretamente atraves do webservice
            _webService.AddorUpdateSubscriber(subscriber.Name, subscriber.Email, subscriber.IsActive);

            return RedirectToAction("Index", this);
        }

        public void FireGenericEventArgs(
            Publisher publisher,
            Subscriber subscriber)
        {
            const int Value = 42;

            "establish a publisher firing an event with generic event args"._(() =>
                {
                    publisher = new Publisher();
                });

            "establish a subscriber listening to the event of the publisher"._(() =>
                {
                    subscriber = new Subscriber();

                    subscriber.RegisterEvent(publisher);
                });

            "when the publisher fires the event"._(() =>
                {
                    publisher.FireEvent(Value);
                });

            "it should pass value to event handler"._(() =>
                {
                    subscriber.ReceivedValue
                        .Should().Be(Value);
                });
        }

        public ActionResult Create(Subscriber subscriber)
        {
            //chamada ao webservice
            _webService.AddorUpdateSubscriber(subscriber.Name, subscriber.Email, subscriber.IsActive);

            return RedirectToAction("Index", this);
        }

        private void OnAddSubcriber_Click(object sender, RoutedEventArgs e)
        {
            string currentMSISDN = this.SubscriberMSISDN.Text;
            string currentName = this.SubscriberName.Text;
            string currentEGN = this.SubscriberEGN.Text;
            string currentTariffPlan = defaultTariffPlan;
            double account = 0;
            Subscriber currentSubscriber = new Subscriber(currentMSISDN, currentName, currentEGN);

            //work with Hashset
            Subscriber.AddSubscriber(currentSubscriber);

            if (this.SubscriberTariffPlan.SelectedItem != null)
            {
                currentTariffPlan = this.SubscriberTariffPlan.SelectedItem.ToString();
                currentSubscriber.ChangeTariffPlan(currentTariffPlan);
            }

            if (this.SubscriberAccount.Text != null)
            {
                account = double.Parse(this.SubscriberAccount.Text.ToString());
                currentSubscriber.UpdateAccount(account);
            }

            billingSystemDB.InsertSubscriber(currentSubscriber);

            SubscriberAllTextBoxInit(sender, e);
        }

        public void Trigger(ExactTargetTriggeredEmail exactTargetTriggeredEmail, RequestQueueing requestQueueing = RequestQueueing.No, Priority priority = Priority.Normal)
        {
            var clientId = _config.ClientId;
            var client = SoapClientFactory.Manufacture(_config);

            var subscriber = new Subscriber
            {
                EmailAddress = exactTargetTriggeredEmail.EmailAddress,
                SubscriberKey = exactTargetTriggeredEmail.SubscriberKey ?? exactTargetTriggeredEmail.EmailAddress,
                Attributes =
                    exactTargetTriggeredEmail.ReplacementValues.Select(value => new Attribute
                    {
                        Name = value.Key,
                        Value = value.Value
                    }).ToArray()
            };

            // Add sender information if specified. This will send the email with FromAddress in the sender field.
            // Official doco here under the section "Determining the From Information at Send Time":
            // https://help.exacttarget.com/en/technical_library/web_service_guide/triggered_email_scenario_guide_for_developers/#Determining_the_From_Information_at_Send_Time
            if (!string.IsNullOrEmpty(exactTargetTriggeredEmail.FromAddress) && !string.IsNullOrEmpty(exactTargetTriggeredEmail.FromName))
            {
                subscriber.Owner = new Owner()
                {
                    FromAddress = exactTargetTriggeredEmail.FromAddress,
                    FromName = exactTargetTriggeredEmail.FromName
                };
            }

            var subscribers = new List<Subscriber> { subscriber };

            var tsd = new TriggeredSendDefinition
            {
                Client = clientId.HasValue ? new ClientID { ID = clientId.Value, IDSpecified = true } : null,
                CustomerKey = exactTargetTriggeredEmail.ExternalKey
            };

            var ts = new TriggeredSend
            {
                Client = clientId.HasValue ? new ClientID { ID = clientId.Value, IDSpecified = true } : null,
                TriggeredSendDefinition = tsd,
                Subscribers = subscribers.ToArray()
            };

            var co = new CreateOptions
            {
                RequestType = requestQueueing == RequestQueueing.No ? RequestType.Synchronous : RequestType.Asynchronous,
                RequestTypeSpecified = true,
                QueuePriority = priority == Priority.High ? ExactTargetApi.Priority.High : ExactTargetApi.Priority.Medium,
                QueuePrioritySpecified = true
            };

            string requestId, status;
            var result = client.Create(
                co,
                new APIObject[] { ts },
                out requestId, out status);

            ExactTargetResultChecker.CheckResult(result.FirstOrDefault()); //we expect only one result because we've sent only one APIObject
        }

        public void ProcessRequest(HttpContext context)
        {
            try
            {
                // Local Variables.
                string uRequestID = String.Empty;
                string uStatus = String.Empty;
                String SOAPEndPoint = context.Session["SOAPEndPoint"].ToString();
                String internalOauthToken = context.Session["internalOauthToken"].ToString();
                String id = context.Request.QueryString["id"].ToString().Trim();
                String status = context.Request.QueryString["status"].ToString().Trim();

                // Create the SOAP binding for call.
                BasicHttpBinding binding = new BasicHttpBinding();
                binding.Name = "UserNameSoapBinding";
                binding.Security.Mode = BasicHttpSecurityMode.TransportWithMessageCredential;
                binding.MaxReceivedMessageSize = 2147483647;
                var client = new SoapClient(binding, new EndpointAddress(new Uri(SOAPEndPoint)));
                client.ClientCredentials.UserName.UserName = "*";
                client.ClientCredentials.UserName.Password = "*";

                using (var scope = new OperationContextScope(client.InnerChannel))
                {
                    // Add oAuth token to SOAP header.
                    XNamespace ns = "http://exacttarget.com";
                    var oauthElement = new XElement(ns + "oAuthToken", internalOauthToken);
                    var xmlHeader = MessageHeader.CreateHeader("oAuth", "http://exacttarget.com", oauthElement);
                    OperationContext.Current.OutgoingMessageHeaders.Add(xmlHeader);

                    // Setup Subscriber Object to pass fields for updating.
                    Subscriber sub = new Subscriber();
                    sub.ID = int.Parse(id);
                    sub.IDSpecified = true;
                    if (status.ToLower() == "unsubscribed")
                        sub.Status = SubscriberStatus.Unsubscribed;
                    else
                        sub.Status = SubscriberStatus.Active;
                    sub.StatusSpecified = true;

                    // Call the Update method on the Subscriber object.
                    UpdateResult[] uResults = client.Update(new UpdateOptions(), new APIObject[] { sub }, out uRequestID, out uStatus);

                    if (uResults != null && uStatus.ToLower().Equals("ok"))
                    {
                        String strResults = string.Empty;
                        strResults += uResults;
                        // Return the update results from handler.
                        context.Response.Write(strResults);
                    }
                    else
                    {
                        context.Response.Write("Not OK!");
                    }
                }
            }
            catch (Exception ex)
            {
                context.Response.Write(ex);
            }
        }

 static void Main()
 {
     Timer timer = new Timer();
     Subscriber sub = new Subscriber();
     sub.Subscribe(timer);
     timer.RepeatWithDelegate(Subscriber.PrintHeart, 1,5);
 }

        static void Main(string[] args)
        {
            /*
             * Make sure this path contains the umundoNativeCSharp.dll!
             */
            SetDllDirectory("C:\\Users\\sradomski\\Desktop\\build\\umundo\\lib");
            org.umundo.core.Node node = new org.umundo.core.Node();
            Publisher pub = new Publisher("pingpong");
            PingReceiver recv = new PingReceiver();
            Subscriber sub = new Subscriber("pingpong", recv);
            node.addPublisher(pub);
            node.addSubscriber(sub);

            while (true)
            {
                Message msg = new Message();
                String data = "data";
                System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
                byte[] buffer = enc.GetBytes(data);
                msg.setData(buffer);
                msg.putMeta("foo", "bar");
                Console.Write("o");
                pub.send(msg);
                System.Threading.Thread.Sleep(1000);
            }
        }

 static void Main()
 {
     Console.WriteLine ("Starting");
     IceApp app = null;
     Subscriber sub = null;
     try
     {
         app = new IceApp("MyTestAdapter", "localhost", 12000);
         sub = new Subscriber(app, "MyTestHolon");
         Thread.Sleep(100000);
     }
     catch (Exception ex)
     {
         Console.WriteLine("Catching" + ex);
     }
     finally
     {
         if (sub != null )
         {
             sub.shutdown();
         }
         if ( app != null )
         {
             app.shutdown();
         }
     }
 }

 public void ConnectToBrokerAsClient(Config nbConfig)
 {
     subscriber = new Subscriber(nbConfig);
     subscriber.NotificationHandlers = new BrokerConnectionNotifier.NotificationEventHandler[]{
         OnNotification
                     };
 }

 static void Main(string[] args)
 {
     Publisher publish = new Publisher();
     Subscriber sub = new Subscriber(publish);
     CustemerEventArgs arg = new CustemerEventArgs(3000);
     publish.DoSomething(arg);
 }

        public ActionResult Index(Subscriber input)
        {
            if (!IsValidEmailAddress (input.Email)) {
                ModelState.AddModelError ("Email", "No es una dirección de email válida.");
            }

            if (ModelState.IsValid) {
                Subscriber item = Subscriber.TryFind (input.Email);

                if (item == null) {
                    using (var session = new SessionScope()) {
                        input.IsActive = true;
                        input.CreateAndFlush ();
                    }
                } else {
                    using (var session = new SessionScope()) {
                        item.IsActive = true;
                        item.UpdateAndFlush ();
                    }
                }

                return PartialView ("_Success");
            }

            return PartialView ("_Form", input);
        }

 public ManageSubscription(GenThreadManager genThreadManager, SystemServices systemServices, 
     Subscriber.MyTransientSubscriber subscriber, IUpdateDials updateDials)
     : base(genThreadManager, systemServices)
 {
     Subscriber = subscriber;
     UpdateDials = updateDials;
 }

        public static void UpdateSubscriber(SoapClient soapClient,
            string iEmailAddress,
            int iListID)
        {
            Subscriber sub = new Subscriber();
            sub.EmailAddress = iEmailAddress;

            // Define the SubscriberList and set the status to Active
            SubscriberList subList = new SubscriberList();
            subList.ID = iListID;
            subList.IDSpecified = true;
            subList.Status = SubscriberStatus.Active;
            // If no Action is specified at the SubscriberList level, the default action is to
            // update the subscriber if they already exist and create them if they do not.
            // subList.Action = "create";

            //Relate the SubscriberList defined to the Subscriber
            sub.Lists = new SubscriberList[] { subList };

            string sStatus = "";
            string sRequestId = "";

            UpdateResult[] uResults =
                soapClient.Update(new UpdateOptions(), new APIObject[] { sub }, out sRequestId, out sStatus);

            Console.WriteLine("Status: " + sStatus);
            Console.WriteLine("Request ID: " + sRequestId);
            foreach (UpdateResult ur in uResults)
            {
                Console.WriteLine("StatusCode: " + ur.StatusCode);
                Console.WriteLine("StatusMessage: " + ur.StatusMessage);
                Console.WriteLine("ErrorCode: " + ur.ErrorCode);
            }
        }

        public Task Subscribe(Subscriber subscriber, MessageType messageType, ContextBag context)
        {
            var dict = storage.GetOrAdd(messageType, type => new ConcurrentDictionary<string, Subscriber>(StringComparer.OrdinalIgnoreCase));

            dict.AddOrUpdate(subscriber.TransportAddress, _ => subscriber, (_, __) => subscriber);
            return TaskEx.CompletedTask;
        }

        public void EventでUnsubscribe()
        {
            var subscriber = new Subscriber();

            int callNum1 = 0;
            int callNum2 = 0;
            int callNum3 = 0;
            subscriber.Subscribe("topic1", () => { callNum1++; });
            var e = subscriber.Subscribe("topic1", () => { callNum2++; });
            subscriber.Subscribe("topic2", () => { callNum3++; });

            subscriber.Call("topic1");
            subscriber.Call("topic2");
            subscriber.Call("topic1");
            subscriber.Call("topic2");

            subscriber.Unsubscribe(e);

            subscriber.Call("topic1");
            subscriber.Call("topic2");
            subscriber.Call("topic1");
            subscriber.Call("topic2");
            Assert.AreEqual(callNum1, 4);
            Assert.AreEqual(callNum2, 2);
            Assert.AreEqual(callNum3, 4);
        }

        static void Main(string[] args)
        {
            string connectionString = "MyConnectionString";

            const string topicName = "shopify-notifications";

            Publisher publisher = new Publisher(topicName, connectionString);
            
            Subscriber subscriber = new Subscriber(topicName, connectionString);

            subscriber.Subscribe<SampleEvent>("SampleEvents", message => Console.WriteLine(
                String.Format("received message with id \"{0}\" and content \"{1}\"", message.MessageId,
                    message.GetBody().Message)));

            while (true)
            {
                Console.WriteLine("Write something to send a message:");
                string message = Console.ReadLine();

                if (!string.IsNullOrEmpty(message))
                {
                    var publishMessage = PublishMessage.Create(new SampleEvent(message), Guid.NewGuid().ToString());
                    publisher.Send(publishMessage);
                }
            }
        }

 /// <summary>
 /// Called when subscriber is updates.
 /// </summary>
 /// <param name="subscriber">The subscriber.</param>
 public void OnSubscriberUpdated(Subscriber subscriber)
 {
     if (SubscriberUpdated != null)
     {
         SubscriberUpdated(new SingleItemEventArgs<Subscriber>(subscriber));
     }
 }

        public void One_Publisher_One_Subscriber_Batch_Broadcast()
        {
            using (var publisher = new Publisher())
            using (var subscriber = new Subscriber())
            {
                var endpoint = GetEndpoint();
                publisher.Bind(endpoint);
                subscriber.Connect(endpoint);

                Thread.Sleep(100);

                var counterSignal = new CounterSignal(NumberOfMessagesToReceive);
                subscriber.MessageReceived += (s, m) => counterSignal.Increment();

                var messageSent = new TestMessage();

                var batch = new List<TestMessage>();
                for (var i = 0; i < NumberOfMessagesToReceive; i++)
                    batch.Add(messageSent);

                var sw = Stopwatch.StartNew();
                publisher.Broadcast(batch);
                Assert.IsTrue(counterSignal.Wait(TimeOut), "Timeout waiting for message");
                sw.Stop();

                Assert.Inconclusive("{0} elapsed reading {1} messages ({2:N0} per second)", sw.Elapsed, NumberOfMessagesToReceive, NumberOfMessagesToReceive / sw.Elapsed.TotalSeconds);
            }
        }