Example #1
0
        public void RoomForCreamNotifyChanges()
        {
            JurassicJava coffee = new JurassicJava();

            Assert.PropertyChanged(coffee, "Ingredients", () => coffee.LeaveRoomForCream());
            Assert.PropertyChanged(coffee, "Special", () => coffee.LeaveRoomForCream());
        }
        public void LeaveRoomForCreamShouldNotifySpecialChange()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.PropertyChanged(java, "Special", () =>
            {
                java.LeaveRoomForCream();
            });
        }
Example #3
0
        public void CheckPropertyChangedJurassicJava()
        {
            JurassicJava ft = new JurassicJava();

            Assert.PropertyChanged(ft, "Price", () => ft.Price *= 2);
            Assert.PropertyChanged(ft, "Size", () => ft.Size    = Size.Medium);
            Assert.PropertyChanged(ft, "Special", () => ft.LeaveRoomForCream());
            Assert.PropertyChanged(ft, "Room For Cream", () => ft.LeaveRoomForCream());
            Assert.PropertyChanged(ft, "Ice", () => ft.AddIce());
        }
Example #4
0
        public void RoomForCreamShouldChangeSpecial()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.Contains <string>("Leave Room For Cream", java.Special);
        }
        public void CheckCream()
        {
            JurassicJava j = new JurassicJava();

            j.LeaveRoomForCream();
            Assert.True(j.RoomForCream);
        }
        public void InvokingLeaveSpaceForCreamResultsInSpaceForCreamPropertyToTrue()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.True(java.RoomForCream);
        }
Example #7
0
        public void LeavingSpaceLeavesSpace()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.True(java.RoomForCream);
        }
        public void ShouldLeaveRoomForCream()
        {
            JurassicJava ch = new JurassicJava();

            ch.LeaveRoomForCream();
            Assert.True(ch.RoomForCream);
        }
Example #9
0
        public void CanLeaveRoomForCream()
        {
            JurassicJava t = new JurassicJava();

            t.LeaveRoomForCream();
            Assert.True(t.RoomForCream);
        }
Example #10
0
        public void HasRoomForCream()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.True(java.roomForCream == true);
        }
Example #11
0
        public void ShouldHaveCorrectSpecialAfterLeavingRoomForCream()
        {
            JurassicJava jj = new JurassicJava();

            jj.LeaveRoomForCream();
            Assert.Contains <string>("Leave Room For Cream", jj.Special);
        }
Example #12
0
        public void ShouldLeaveRoomForCream()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.Equal(true, java.RoomForCream);
        }
Example #13
0
        public void ShouldLeaveSpaceForCream()
        {
            JurassicJava j = new JurassicJava();

            j.LeaveRoomForCream();
            Assert.True(j.RoomForCream);
        }
Example #14
0
        public void ShouldHaveCorrectSpecialCream()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.Contains("Leave Room For Cream", java.Special);
        }
Example #15
0
        public void IceAndCreamShouldNotifySpecial()
        {
            JurassicJava java = new JurassicJava();

            Assert.PropertyChanged(java, "Special", () => java.AddIce());
            Assert.PropertyChanged(java, "Special", () => java.LeaveRoomForCream());
        }
Example #16
0
        public void ShouldHaveSpecialDescription()
        {
            JurassicJava j = new JurassicJava();

            j.AddIce();
            Assert.Collection <string>(j.Special, item =>
            {
                Assert.Equal("Add Ice", item);
            });
            j.Ice = false;
            j.MakeDecaf();
            Assert.Collection(j.Special, item =>
            {
                Assert.Equal("Make Decaf", item);
            });
            j.Decaf = false;
            j.LeaveRoomForCream();
            Assert.Collection(j.Special, item =>
            {
                Assert.Equal("Leave Room For Cream", item);
            });
            j.AddIce();
            j.MakeDecaf();
            string[] specials = new string[] { "Leave Room For Cream", "Add Ice", "Make Decaf" };
            Assert.Equal(j.Special, specials);
        }
Example #17
0
        public void ShouldLeaveSpaceForCream()
        {
            JurassicJava coffee = new JurassicJava();

            coffee.LeaveRoomForCream();
            Assert.True(coffee.RoomForCream);
        }
        public void ShouldHaveCorrectSpecialInstructions3()
        {
            PterodactylWings p = new PterodactylWings();
            MezzorellaSticks m = new MezzorellaSticks();
            JurassicJava     j = new JurassicJava();

            j.LeaveRoomForCream();
            CretaceousCombo c = new CretaceousCombo(p);

            c.Side  = m;
            c.Drink = j;
            c.Size  = Size.Medium;
            Assert.Collection <string>(c.Special, item =>
            {
                Assert.Equal("Medium Mezzorella Sticks", item);
            },
                                       item =>
            {
                Assert.Equal("Medium Jurassic Java", item);
            },
                                       item =>
            {
                Assert.Equal("Leave Room For Cream", item);
            });
        }
Example #19
0
        public void LeaveSpaceForCreamCheck()
        {
            JurassicJava jj = new JurassicJava();

            jj.LeaveRoomForCream();
            Assert.True(jj.RoomForCream);
        }
Example #20
0
        public void LeaveRoomForCreamResultsInTrueRoomForCream()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.True(java.RoomForCream);
        }
        public void LeaveSpaceForCreamWorks()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.True(java.RoomForCream);
        }
Example #22
0
        public void SpecialShouldLeaveSpaceForCream()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.Contains("Leave Space For Cream", java.Special);
        }
Example #23
0
        public void LeaveRoomForCreamShouldLeaveRoom()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.True(java.RoomForCream);
        }
Example #24
0
        public void LeaveRoomForCreamAddsRoomForCream()
        {
            JurassicJava drink = new JurassicJava();

            drink.LeaveRoomForCream();
            Assert.True(drink.RoomForCream);
        }
Example #25
0
        public void ShouldLeaveRoomForCreamAfterLeaveRoomForCream()
        {
            JurassicJava jj = new JurassicJava();

            jj.LeaveRoomForCream();
            Assert.True(jj.RoomForCream);
        }
Example #26
0
        public void LeaveRoomForCreamAddsRoomForCreamToSpecial()
        {
            JurassicJava drink = new JurassicJava();

            drink.LeaveRoomForCream();
            Assert.Equal("Leave Room For Cream", drink.Special[0]);
        }
Example #27
0
        public void ShouldBeAbleToLeaveSpaceForCream()
        {
            JurassicJava ss = new JurassicJava();

            ss.LeaveRoomForCream();
            Assert.True(ss.RoomForCream);
        }
        public void ShouldNotifyOfSpecialPropertyChange()
        {
            JurassicJava jj = new JurassicJava();

            Assert.PropertyChanged(jj, "Special", () => jj.AddIce());
            Assert.PropertyChanged(jj, "Special", () => jj.LeaveRoomForCream());
        }
Example #29
0
        public void CombosOfOptionsWork(bool addIce, bool leaveRoom)
        {
            JurassicJava j = new JurassicJava();

            if (addIce)
            {
                j.AddIce();
            }
            if (leaveRoom)
            {
                j.LeaveRoomForCream();
            }
            if (addIce)
            {
                Assert.True(Array.Exists <string>(j.Special, element => element.Equals("Add Ice")));
            }
            if (leaveRoom)
            {
                Assert.True(Array.Exists <string>(j.Special, element => element.Equals("Leave Room For Cream")));
            }
            if (!addIce)
            {
                Assert.False(Array.Exists <string>(j.Special, element => element.Equals("Add Ice")));
            }
            if (!leaveRoom)
            {
                Assert.False(Array.Exists <string>(j.Special, element => element.Equals("Leave Room For Cream")));
            }
        }
Example #30
0
        public void CorrectRoomForCream()
        {
            JurassicJava java = new JurassicJava();

            java.LeaveRoomForCream();
            Assert.True(java.RoomForCream);
        }