public void MacroCommandtest()
        {
            Remote remote = new Remote();

            Light light = new Light();
            Stero stero = new Stero();
            Fan   fan   = new Fan();

            LightOnCommand       lightOn = new LightOnCommand(light);
            SteroOnWithCDCommand steroOn = new SteroOnWithCDCommand(stero);
            FanHighCommand       fanOn   = new FanHighCommand(fan);

            LightOffCommand lightOff = new LightOffCommand(light);
            SteroOffCommand steroOff = new SteroOffCommand(stero);
            FanOffCommand   fanOff   = new FanOffCommand(fan);

            MacroCommand macroCommandOn  = new MacroCommand(new ICommand[] { lightOn, steroOn, fanOn });
            MacroCommand macroCommandOff = new MacroCommand(new ICommand[] { lightOff, steroOff, fanOff });

            remote.SetCommnd(0, macroCommandOn, macroCommandOff);
            remote.OnButtonPressed(0);

            Assert.AreEqual(Light.States.On, light.CurrentState);
            Assert.AreEqual(Stero.State.CD, stero.CurrentState);
            Assert.AreEqual((int)11, stero.Volume);
            Assert.AreEqual(Fan.Speed.High, fan.CurrentSpeed);

            remote.OffButtonPressed(0);
            Assert.AreEqual(Light.States.Off, light.CurrentState);
            Assert.AreEqual(Stero.State.Off, stero.CurrentState);
            Assert.AreEqual((int)0, stero.Volume);
            Assert.AreEqual(Fan.Speed.Off, fan.CurrentSpeed);
        }
        void ShouldUndoFanByPrevCommonStatus()
        {
            //Arrange
            var remoteControl = new RemoteControl();

            var fan = new Fan();

            var fanHighCommand = new FanHighCommand(fan);

            var fanOffCommand = new FanOffCommand(fan);

            remoteControl.SetCommand(2, fanHighCommand, fanOffCommand);

            //Assert
            Assert.Equal("fan high", remoteControl.OnButtonWasPushed(2));
            Assert.Equal("fan off", remoteControl.OffButtonWasPushed(2));
            Assert.Equal("fan high", remoteControl.UndoButtonWasPushed());
        }
Example #3
0
            public void FanTest()
            {
                var ktFan              = new Fan("客厅");
                var ktFanHighCommand   = new FanHighCommand(ktFan);
                var ktFanMediumCommand = new FanMediumCommand(ktFan);
                var ktFanLowCommand    = new FanLowCommand(ktFan);
                var ktFanOffCommand    = new FanOffCommand(ktFan);

                var fanRemoteControl = new RemoteControl();

                fanRemoteControl.SetCommand(0, ktFanHighCommand, ktFanOffCommand);
                fanRemoteControl.SetCommand(1, ktFanMediumCommand, ktFanOffCommand);
                fanRemoteControl.SetCommand(2, ktFanLowCommand, ktFanOffCommand);

                fanRemoteControl.OnClick(0);
                //fanRemoteControl.OffClick(0);
                fanRemoteControl.OnClick(1);
                fanRemoteControl.OnClick(2);
                fanRemoteControl.OnClick(0);
                fanRemoteControl.Undo();
            }
        void ShouldUseMacroCommand()
        {
            //Arrange
            var fan = new Fan();

            var fanHighCommand = new FanHighCommand(fan);

            var fanOffCommand = new FanOffCommand(fan);

            var light = new Light();

            var lightOnCommand = new LightOnCommand(light);

            var lightOffCommand = new LightOffCommand(light);

            var partyOn = new List <ICommand> {
                lightOnCommand, fanHighCommand
            };

            var partyOff = new List <ICommand> {
                lightOffCommand, fanOffCommand
            };

            var partyOnMacro = new MacroCommand(partyOn);

            var partyOffMacro = new MacroCommand(partyOff);

            var remoteControl = new RemoteControl();

            remoteControl.SetCommand(0, partyOnMacro, partyOffMacro);

            //Assert
            Assert.Equal("light on, fan high", remoteControl.OnButtonWasPushed(0));
            Assert.Equal("light off, fan off", remoteControl.OffButtonWasPushed(0));
            Assert.Equal("light on, fan high", remoteControl.UndoButtonWasPushed());
        }
        static void Main(string[] args)                                     // Client
        {
            // Example 1
            SimpleRemoteControl remote         = new SimpleRemoteControl(); // Invoker
            LightBulb           light          = new LightBulb();           // Receiver
            LightOnCommand      lightOnCommand = new LightOnCommand(light); // Command

            remote.SetCommand(lightOnCommand);
            remote.ButtonWasPressed();
            remote.UndoButtonWasPressed();

            // Example 2
            AdvancedRemote remote2 = new AdvancedRemote();

            GarageDoor garageDoor = new GarageDoor();
            Stereo     stereo     = new Stereo();

            GarageDoorUpCommand   garageDoorUpCommand   = new GarageDoorUpCommand(garageDoor);
            GarageDoorDownCommand garageDoorDownCommand = new GarageDoorDownCommand(garageDoor);

            StereoOnCommand  stereoOnCommand  = new StereoOnCommand(stereo);
            StereoOffCommand stereoOffCommand = new StereoOffCommand(stereo);

            remote2.SetCommand(0, garageDoorUpCommand, garageDoorDownCommand);
            remote2.SetCommand(1, stereoOnCommand, stereoOffCommand);

            remote2.OnButtonWasPressed(0);
            remote2.OnButtonWasPressed(1);
            remote2.OffButtonWasPressed(0);
            remote2.OffButtonWasPressed(1);

            remote2.UndoButtonWasPressed();

            // Example 3

            AdvancedRemote remote3 = new AdvancedRemote();

            Fan fan = new Fan();

            FanHighCommand   fanHighCommand   = new FanHighCommand(fan);
            FanMeduimCommand fanMeduimCommand = new FanMeduimCommand(fan);
            FanLowCommand    fanLowCommand    = new FanLowCommand(fan);
            FanOffCommand    fanOffCommand    = new FanOffCommand(fan);

            // Remote from Example 2 Reused
            remote3.SetCommand(0, fanHighCommand, fanOffCommand);
            remote3.SetCommand(1, fanMeduimCommand, fanOffCommand);

            remote3.OnButtonWasPressed(0);              // High
            remote3.OffButtonWasPressed(0);             // Off
            remote3.UndoButtonWasPressed();             // Back To High

            // Example 4
            RoomTV          roomTV          = new RoomTV();
            HotTub          hotTub          = new HotTub();
            HotTubOnCommand hotTubOnCommand = new HotTubOnCommand(hotTub);

            TVOnCommand tvOnCommand = new TVOnCommand(roomTV);

            Command[] PartyCommands = new Command[2];
            PartyCommands[0] = hotTubOnCommand;
            PartyCommands[1] = tvOnCommand;


            MacroCommand macroCommand = new MacroCommand(PartyCommands);    // Put All Commands in this MacroCommand

            AdvancedRemote remote4 = new AdvancedRemote();

            remote4.SetCommand(0, macroCommand, new NoCommand());           // No Command for Off Button
            remote4.OnButtonWasPressed(0);
        }
        public void RemoteTest()
        {
            Remote remote = new Remote();

            Light      livingRoomLight = new Light();
            Light      kitchenLight    = new Light();
            Fan        fan             = new Fan();
            GarageDoor door            = new GarageDoor();
            Stero      stero           = new Stero();

            LightOnCommand       livingRoomLightOn  = new LightOnCommand(livingRoomLight);
            LightOnCommand       kitchenLightOn     = new LightOnCommand(kitchenLight);
            LightOffCommand      livingRoomLightOff = new LightOffCommand(livingRoomLight);
            LightOffCommand      kitchenlightOff    = new LightOffCommand(kitchenLight);
            FanHighCommand       fanHighCommand     = new FanHighCommand(fan);
            FanOffCommand        fanOffCommand      = new FanOffCommand(fan);
            DoorUpCommand        doorUpCommand      = new DoorUpCommand(door);
            DoorDownCommand      doorDownCommand    = new DoorDownCommand(door);
            SteroOnWithCDCommand steroOn            = new SteroOnWithCDCommand(stero);
            SteroOffCommand      steroOff           = new SteroOffCommand(stero);

            remote.SetCommnd(0, livingRoomLightOn, livingRoomLightOff);
            remote.SetCommnd(1, kitchenLightOn, kitchenlightOff);
            remote.SetCommnd(2, fanHighCommand, fanOffCommand);
            remote.SetCommnd(3, doorUpCommand, doorDownCommand);
            remote.SetCommnd(4, steroOn, steroOff);


            Assert.AreEqual(Light.States.Off, livingRoomLight.CurrentState);
            Assert.AreEqual(Light.States.Off, kitchenLight.CurrentState);
            Assert.AreEqual(Fan.Speed.Off, fan.CurrentSpeed);
            Assert.AreEqual(GarageDoor.DoorStates.Down, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.Off, door.LightState);
            Assert.AreEqual((int)0, stero.Volume);
            Assert.AreEqual(Stero.State.Off, stero.CurrentState);

            remote.OnButtonPressed(0);
            Assert.AreEqual(Light.States.On, livingRoomLight.CurrentState);
            Assert.AreEqual(Light.States.Off, kitchenLight.CurrentState);
            Assert.AreEqual(Fan.Speed.Off, fan.CurrentSpeed);
            Assert.AreEqual(GarageDoor.DoorStates.Down, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.Off, door.LightState);
            Assert.AreEqual((int)0, stero.Volume);
            Assert.AreEqual(Stero.State.Off, stero.CurrentState);

            remote.OnButtonPressed(1);
            Assert.AreEqual(Light.States.On, livingRoomLight.CurrentState);
            Assert.AreEqual(Light.States.On, kitchenLight.CurrentState);
            Assert.AreEqual(Fan.Speed.Off, fan.CurrentSpeed);
            Assert.AreEqual(GarageDoor.DoorStates.Down, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.Off, door.LightState);
            Assert.AreEqual((int)0, stero.Volume);
            Assert.AreEqual(Stero.State.Off, stero.CurrentState);

            remote.OnButtonPressed(2);
            Assert.AreEqual(Fan.Speed.High, fan.CurrentSpeed);
            Assert.AreEqual(GarageDoor.DoorStates.Down, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.Off, door.LightState);
            Assert.AreEqual((int)0, stero.Volume);
            Assert.AreEqual(Stero.State.Off, stero.CurrentState);

            remote.OnButtonPressed(3);
            Assert.AreEqual(GarageDoor.DoorStates.Up, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.On, door.LightState);
            Assert.AreEqual((int)0, stero.Volume);
            Assert.AreEqual(Stero.State.Off, stero.CurrentState);

            remote.OnButtonPressed(4);
            Assert.AreEqual((int)11, stero.Volume);
            Assert.AreEqual(Stero.State.CD, stero.CurrentState);

            remote.OffButtonPressed(0);
            Assert.AreEqual(Light.States.Off, livingRoomLight.CurrentState);
            Assert.AreEqual(Light.States.On, kitchenLight.CurrentState);
            Assert.AreEqual(Fan.Speed.High, fan.CurrentSpeed);
            Assert.AreEqual(GarageDoor.DoorStates.Up, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.On, door.LightState);
            Assert.AreEqual((int)11, stero.Volume);
            Assert.AreEqual(Stero.State.CD, stero.CurrentState);

            remote.OffButtonPressed(1);
            Assert.AreEqual(Light.States.Off, livingRoomLight.CurrentState);
            Assert.AreEqual(Light.States.Off, kitchenLight.CurrentState);
            Assert.AreEqual(GarageDoor.DoorStates.Up, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.On, door.LightState);
            Assert.AreEqual((int)11, stero.Volume);
            Assert.AreEqual(Stero.State.CD, stero.CurrentState);

            remote.OffButtonPressed(2);
            Assert.AreEqual(Light.States.Off, livingRoomLight.CurrentState);
            Assert.AreEqual(Light.States.Off, kitchenLight.CurrentState);
            Assert.AreEqual(Fan.Speed.Off, fan.CurrentSpeed);
            Assert.AreEqual(GarageDoor.DoorStates.Up, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.On, door.LightState);
            Assert.AreEqual((int)11, stero.Volume);
            Assert.AreEqual(Stero.State.CD, stero.CurrentState);

            remote.OffButtonPressed(3);
            remote.OffButtonPressed(3);
            Assert.AreEqual(Light.States.Off, livingRoomLight.CurrentState);
            Assert.AreEqual(Light.States.Off, kitchenLight.CurrentState);
            Assert.AreEqual(Fan.Speed.Off, fan.CurrentSpeed);
            Assert.AreEqual(GarageDoor.DoorStates.Down, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.Off, door.LightState);
            Assert.AreEqual((int)11, stero.Volume);
            Assert.AreEqual(Stero.State.CD, stero.CurrentState);

            remote.OffButtonPressed(4);
            Assert.AreEqual(Light.States.Off, livingRoomLight.CurrentState);
            Assert.AreEqual(Light.States.Off, kitchenLight.CurrentState);
            Assert.AreEqual(Fan.Speed.Off, fan.CurrentSpeed);
            Assert.AreEqual(GarageDoor.DoorStates.Down, door.DoorState);
            Assert.AreEqual(GarageDoor.LightStates.Off, door.LightState);
            Assert.AreEqual((int)0, stero.Volume);
            Assert.AreEqual(Stero.State.Off, stero.CurrentState);
        }