Esempio n. 1
0
        public void Listener()
        {
            Mesh m = new Mesh();

            CounterListener l = new CounterListener();

            m.AddListener(l);

            var a = m.GetVertex(new Vector3(0, 0, 1));

            Assert.AreEqual(1, l.Vertices);
            Assert.AreEqual(0, l.Edges);
            Assert.AreEqual(0, l.Faces);

            m.Delete(a);
            Assert.AreEqual(0, l.Vertices);
            Assert.AreEqual(0, l.Edges);
            Assert.AreEqual(0, l.Faces);

            a = m.GetVertex(new Vector3(0, 0, 1));
            Assert.AreEqual(1, l.Vertices);
            Assert.AreEqual(0, l.Edges);
            Assert.AreEqual(0, l.Faces);

            var b = m.GetVertex(new Vector3(0, 0, 2));

            Assert.AreEqual(2, l.Vertices);
            Assert.AreEqual(0, l.Edges);
            Assert.AreEqual(0, l.Faces);

            var c = m.GetVertex(new Vector3(0, 0, 3));

            Assert.AreEqual(3, l.Vertices);
            Assert.AreEqual(0, l.Edges);
            Assert.AreEqual(0, l.Faces);

            var d = m.GetVertex(new Vector3(0, 0, 4));

            Assert.AreEqual(4, l.Vertices);
            Assert.AreEqual(0, l.Edges);
            Assert.AreEqual(0, l.Faces);

            var abcd = m.GetFace(a, b, c, d);

            Assert.AreEqual(4, l.Vertices);
            Assert.AreEqual(4, l.Edges);
            Assert.AreEqual(1, l.Faces);

            abcd.Delete();
            Assert.AreEqual(4, l.Vertices);
            Assert.AreEqual(4, l.Edges);
            Assert.AreEqual(0, l.Faces);

            var ab = m.GetEdge(a, b);

            ab.Delete();
            Assert.AreEqual(4, l.Vertices);
            Assert.AreEqual(3, l.Edges);
            Assert.AreEqual(0, l.Faces);
        }
        public async Task VerifyCountersFireWithCorrectValues()
        {
            // Arrange
            var eventListener = new CounterListener(new[] {
                "requests-per-second",
                "total-requests",
                "current-requests",
                "failed-requests"
            });

            var hostingEventSource = GetHostingEventSource();

            using var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5));

            var rpsValues            = eventListener.GetCounterValues("requests-per-second", timeoutTokenSource.Token).GetAsyncEnumerator();
            var totalRequestValues   = eventListener.GetCounterValues("total-requests", timeoutTokenSource.Token).GetAsyncEnumerator();
            var currentRequestValues = eventListener.GetCounterValues("current-requests", timeoutTokenSource.Token).GetAsyncEnumerator();
            var failedRequestValues  = eventListener.GetCounterValues("failed-requests", timeoutTokenSource.Token).GetAsyncEnumerator();

            eventListener.EnableEvents(hostingEventSource, EventLevel.Informational, EventKeywords.None,
                                       new Dictionary <string, string>
            {
                { "EventCounterIntervalSec", "1" }
            });

            hostingEventSource.RequestStart("GET", "/");

            Assert.Equal(1, await totalRequestValues.FirstOrDefault(v => v == 1));
            Assert.Equal(1, await rpsValues.FirstOrDefault(v => v == 1));
            Assert.Equal(1, await currentRequestValues.FirstOrDefault(v => v == 1));
            Assert.Equal(0, await failedRequestValues.FirstOrDefault(v => v == 0));

            hostingEventSource.RequestStop();

            Assert.Equal(1, await totalRequestValues.FirstOrDefault(v => v == 1));
            Assert.Equal(0, await rpsValues.FirstOrDefault(v => v == 0));
            Assert.Equal(0, await currentRequestValues.FirstOrDefault(v => v == 0));
            Assert.Equal(0, await failedRequestValues.FirstOrDefault(v => v == 0));

            hostingEventSource.RequestStart("POST", "/");

            Assert.Equal(2, await totalRequestValues.FirstOrDefault(v => v == 2));
            Assert.Equal(1, await rpsValues.FirstOrDefault(v => v == 1));
            Assert.Equal(1, await currentRequestValues.FirstOrDefault(v => v == 1));
            Assert.Equal(0, await failedRequestValues.FirstOrDefault(v => v == 0));

            hostingEventSource.RequestFailed();
            hostingEventSource.RequestStop();

            Assert.Equal(2, await totalRequestValues.FirstOrDefault(v => v == 2));
            Assert.Equal(0, await rpsValues.FirstOrDefault(v => v == 0));
            Assert.Equal(0, await currentRequestValues.FirstOrDefault(v => v == 0));
            Assert.Equal(1, await failedRequestValues.FirstOrDefault(v => v == 1));
        }
 public CustomerCounterControl()
 {
     this.InitializeComponent();
     this.ViewModel = new CustomerCounterViewModel();
     this.ViewModel.CounterColor = Util.ToBrush("#686868");  // TODO: get this from dependency property
     try
     {
         this.counterListener = new CounterListener(SettingsHelper.Instance.CustomerCounterEndpoint,
                                                    Util.ToIntSafely(SettingsHelper.Instance.CustomerCounterTiming, 5));
     }
     catch (Exception ex)
     {
         Debug.WriteLine($"Counter: {ex.Message}");
     }
 }
Esempio n. 4
0
 public CustomerCounterVisControl()
 {
     this.InitializeComponent();
     this.ViewModel = new CustomerCounterVisViewModel();
     Loaded        += (sender, args) =>
     {
         this.ViewModel.MaxBarWidth = this.MaxBarWidth;
         this.ViewModel.RescaleToFit();
     };
     try
     {
         this.counterListener = new CounterListener(SettingsHelper.Instance.CustomerCounterEndpoint,
                                                    Util.ToIntSafely(SettingsHelper.Instance.CustomerCounterTiming, 5));
     }
     catch (Exception ex)
     {
         Debug.WriteLine($"CounterVis: {ex.Message}");
     }
 }
Esempio n. 5
0
        /// <summary>
        /// Customer counter reset helper
        /// </summary>
        /// <param name="val">number of customers in store currently</param>
        /// <returns></returns>
        public static async Task <bool> ResetCustomerCounter(int val)
        {
            bool succeeded = false;

            try
            {
                CounterListener counterListener = new CounterListener(SettingsHelper.Instance.CustomerCounterEndpoint,
                                                                      Util.ToIntSafely(SettingsHelper.Instance.CustomerCounterTiming, 5));
                counterListener.StartListening();
                succeeded = await counterListener.ResetAsync(val);

                counterListener.StopListening();
            }
            catch (Exception)
            {
                // Ignore
            }

            return(succeeded);
        }
 public CounterScenario()
 {
     this.InitializeComponent();
     counterListener = new CounterListener("http://13.93.154.123:5001", 5);
 }