public void HoldDressingShouldRemoveDressing()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldDressing();
            Assert.DoesNotContain <string>("Dressing", vw.Ingredients);
        }
        public void HoldDressingShouldChangeSpecial()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldDressing();
            Assert.Contains <string>("Hold Caesar Dressing", vw.Special);
        }
Exemple #3
0
        public void VelociwrapShouldHaveCorrectSpecialHoldDressing()
        {
            VelociWrap pb = new VelociWrap();

            pb.HoldDressing();
            Assert.Contains <string>("Hold Dressing", pb.Special);
        }
        public void ShouldHaveHoldDressingSpecial()
        {
            VelociWrap wrap = new VelociWrap();

            wrap.HoldDressing();
            string[] special = { "Hold Dressing" };
            Assert.Equal(wrap.Special, special);
        }
Exemple #5
0
        public void HoldingShouldNotifySpecialChange()
        {
            VelociWrap vw = new VelociWrap();

            Assert.PropertyChanged(vw, "Special", () => vw.HoldLettuce());
            Assert.PropertyChanged(vw, "Special", () => vw.HoldDressing());
            Assert.PropertyChanged(vw, "Special", () => vw.HoldCheese());
        }
 public void OnHoldDressing(object sender, RoutedEventArgs args)
 {
     wrap.HoldDressing();
     if (combo != null)
     {
         combo.Entree = wrap;
     }
 }
        public void CheckAllNotifyPropertyChanges(string propertyName)
        {
            VelociWrap vw = new VelociWrap();

            Assert.PropertyChanged(vw, propertyName, () => vw.HoldCheese());
            Assert.PropertyChanged(vw, propertyName, () => vw.HoldLettuce());
            Assert.PropertyChanged(vw, propertyName, () => vw.HoldDressing());
        }
Exemple #8
0
        public void HoldingItemsShouldNotifyOfPropertyChange(string s)
        {
            VelociWrap dn = new VelociWrap();

            Assert.PropertyChanged(dn, s, () => { dn.HoldCheese(); });
            Assert.PropertyChanged(dn, s, () => { dn.HoldDressing(); });
            Assert.PropertyChanged(dn, s, () => { dn.HoldLettuce(); });
        }
        public void VelociWrapPropertyChanges()
        {
            VelociWrap vw = new VelociWrap();

            Assert.PropertyChanged(vw, "Special", () => vw.HoldCheese());
            Assert.PropertyChanged(vw, "Special", () => vw.HoldDressing());
            Assert.PropertyChanged(vw, "Special", () => vw.HoldLettuce());
        }
Exemple #10
0
        public void ShouldHaveCorrectSpecialHoldDressing()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldDressing();
            Assert.Contains("Hold Dressing", vw.Special);
            Assert.Single(vw.Special);
        }
        public void SpecialShouldHoldDressing()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldDressing();
            Assert.Collection <string>(vw.Special,
                                       item => { Assert.Equal("Hold Dressing", item); });
        }
Exemple #12
0
        public void AddDressingShouldAddDressing()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldDressing();
            vw.AddDressing();
            Assert.Contains("Ceasar Dressing", vw.Ingredients);
        }
Exemple #13
0
        public void SpecialShouldHoldDressing()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldDressing();
            string[] special = vw.Special;
            Assert.Contains("Hold Dressing", special);
            Assert.Equal <int>(1, special.Length);
        }
Exemple #14
0
        public void HoldDressingShouldNotifyOfSpecialPropertyChange()
        {
            VelociWrap v = new VelociWrap();

            Assert.PropertyChanged(v, "Special", () =>
            {
                v.HoldDressing();
            });
        }
Exemple #15
0
        public void HoldingDressingShouldNotifySpecialChange()
        {
            VelociWrap vc = new VelociWrap();

            Assert.PropertyChanged(vc, "Special", () =>
            {
                vc.HoldDressing();
            });
        }
        public void HoldLettuceAndDressingShouldProvideCorrectSpecial()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldLettuce();
            vw.HoldDressing();
            Assert.Contains("Hold Lettuce", vw.Special);
            Assert.Contains("Hold Dressing", vw.Special);
        }
        public void HoldDressingShouldNotifyOfPropertyChanged(string propertyName)
        {
            VelociWrap wrap = new VelociWrap();

            Assert.PropertyChanged(wrap, propertyName, () =>
            {
                wrap.HoldDressing();
            });
        }
Exemple #18
0
        public void VelociwrapHoldDressingShouldNotifyPropertyChanged()
        {
            VelociWrap wrap = new VelociWrap();

            Assert.PropertyChanged(wrap, "Special", () =>
            {
                wrap.HoldDressing();
            });
        }
        public void HoldDressingShouldNotifyIngredintsChange()
        {
            VelociWrap wrap = new VelociWrap();

            Assert.PropertyChanged(wrap, "Ingredients", () =>
            {
                wrap.HoldDressing();
            });
        }
Exemple #20
0
        public void HoldDressingShouldNotifySpecialChanged()
        {
            VelociWrap vw = new VelociWrap();

            Assert.PropertyChanged(vw, "Special", () =>
            {
                vw.HoldDressing();
            });
        }
        public void HoldingDressingShouldNotifyIngredientsChange()
        {
            VelociWrap vw = new VelociWrap();

            Assert.PropertyChanged(vw, "Ingredients", () =>
            {
                vw.HoldDressing();
            });
        }
Exemple #22
0
        public void HoldingPeppersShouldSpecialChange()
        {
            VelociWrap vw = new VelociWrap();

            Assert.PropertyChanged(vw, "Special", () =>
            {
                vw.HoldDressing();
            });
        }
        public void HoldingDressingShouldNotifyOfPropertyChange(string propertyName)
        {
            VelociWrap vw = new VelociWrap();

            Assert.PropertyChanged(vw, propertyName, () =>
            {
                vw.HoldDressing();
            });
        }
Exemple #24
0
        public void HoldDressingShouldNotifyChange(string expected)
        {
            VelociWrap vw = new VelociWrap();

            Assert.PropertyChanged(vw, expected, () =>
            {
                vw.HoldDressing();
            });
        }
        public void VelociWrapShouldNotify()
        {
            VelociWrap v = new VelociWrap();

            Assert.PropertyChanged(v, "Special", () => v.HoldCheese());

            Assert.PropertyChanged(v, "Special", () => v.HoldDressing());

            Assert.PropertyChanged(v, "Special", () => v.HoldLettuce());
        }
        public void HoldDressingShouldBeInSpecial()
        {
            VelociWrap v = new VelociWrap();

            v.HoldDressing();
            Assert.Collection <string>(v.Special, item =>
            {
                Assert.Equal("Hold Dressing", item);
            });
        }
Exemple #27
0
 private void Click_HoldDressing(object sender, RoutedEventArgs e)
 {
     if (sender.Equals(Button_HoldDressing))
     {
         if (DataContext is Order order)
         {
             _wrap.HoldDressing();
         }
     }
 }
Exemple #28
0
        public void ShouldhaveholdDressingInSpecail()
        {
            VelociWrap bw = new VelociWrap();

            bw.HoldDressing();
            Assert.Collection <string>(bw.Special, item =>
            {
                Assert.Equal("Hold Dressing", item);
            });
        }
Exemple #29
0
        public void HoldDressingShoukdAddToSpecial()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldDressing();
            Assert.Collection <string>(vw.Special, item =>
            {
                Assert.Equal("Hold Ceasar Dressing", item);
            });
        }
Exemple #30
0
        public void SpecialShouldHoldDressingAndCheese()
        {
            VelociWrap vw = new VelociWrap();

            vw.HoldDressing();
            vw.HoldCheese();
            string[] special = vw.Special;
            Assert.Contains("Hold Dressing", special);
            Assert.Contains("Hold Cheese", special);
        }