public void EnigmaMachine_ShouldDecodeWord_WithRotors123()
        {
            // Arrange
            var enigmaMachine = new EnigmaMachine();

            enigmaMachine.ChooseRotors(RotorNumber.Rotor1, RotorNumber.Rotor2, RotorNumber.Rotor3);
            enigmaMachine.SetRotorDials('a', 'a', 'z');

            enigmaMachine.SetPlugboardPair('h', 's');
            enigmaMachine.SetPlugboardPair('a', 'e');
            enigmaMachine.SetPlugboardPair('d', 'j');
            enigmaMachine.SetPlugboardPair('p', 'q');
            enigmaMachine.SetPlugboardPair('g', 'm');
            enigmaMachine.SetPlugboardPair('b', 'c');
            enigmaMachine.SetPlugboardPair('f', 'i');
            enigmaMachine.SetPlugboardPair('k', 'n');
            enigmaMachine.SetPlugboardPair('l', 'o');
            enigmaMachine.SetPlugboardPair('r', 't');

            // Act
            string encodedMessage = enigmaMachine.Encode("hello");

            // Assert
            Assert.AreEqual("ocfkj", encodedMessage);
        }
Esempio n. 2
0
        public HttpResponseMessage Encrypt([FromBody] EnigmaMachineDto enigmaMachineDto, [FromUri] bool leaveWhiteSpace)
        {
            HttpResponseMessage response;
            EnigmaMachine       enigmaMachine;

            try
            {
                enigmaMachine = new EnigmaMachine();
                enigmaMachine.SetPlugboard(enigmaMachineDto.Plugboard.Wiring);

                enigmaMachine.ChooseRotors(
                    (RotorNumber)enigmaMachineDto.Rotor1.RotorNum,
                    (RotorNumber)enigmaMachineDto.Rotor2.RotorNum,
                    (RotorNumber)enigmaMachineDto.Rotor3.RotorNum);

                enigmaMachine.SetRotorDials(
                    enigmaMachineDto.Rotor1.InitialDialSetting,
                    enigmaMachineDto.Rotor2.InitialDialSetting,
                    enigmaMachineDto.Rotor3.InitialDialSetting);

                enigmaMachine.LeaveWhiteSpace(leaveWhiteSpace);

                string encodedMessage = enigmaMachine.Encode(enigmaMachineDto.Text);

                response = Request.CreateResponse(HttpStatusCode.OK, encodedMessage);
            }
            catch (Exception ex)
            {
                response = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex);
            }

            return(response);
        }
        public void TestInitialize()
        {
            enigmaMachine = new EnigmaMachine();
            enigmaMachine.ChooseRotors(RotorNumber.Rotor1, RotorNumber.Rotor2, RotorNumber.Rotor3);

            enigmaMachine.SetPlugboardPair('h', 's');
            enigmaMachine.SetPlugboardPair('a', 'e');
            enigmaMachine.SetPlugboardPair('d', 'j');
            enigmaMachine.SetPlugboardPair('p', 'q');
            enigmaMachine.SetPlugboardPair('g', 'm');
            enigmaMachine.SetRotorDials('a', 'a', 'z');
        }
        public void EnigmaMachine_ShouldDecodeWordWithSpaces_WithRotors312()
        {
            // Arrange
            var enigmaMachine = new EnigmaMachine();

            enigmaMachine.ChooseRotors(RotorNumber.Rotor3, RotorNumber.Rotor1, RotorNumber.Rotor2);
            enigmaMachine.SetRotorDials('g', 'j', 'n');
            enigmaMachine.SetPlugboard(plugboardWiring);
            string plainText = "forbearance";

            // Act
            string encodedMessage = enigmaMachine.Encode(plainText);

            // Assert
            enigmaMachine.SetRotorDials('g', 'j', 'n');
            Assert.AreEqual("jiekfqfgkxz", encodedMessage);
            Assert.AreEqual(plainText, enigmaMachine.Encode(encodedMessage));
        }
        public void EnigmaMachine_ShouldDecodeWordWithSpaces_WithRotors531()
        {
            // Arrange
            var enigmaMachine = new EnigmaMachine();

            enigmaMachine.ChooseRotors(RotorNumber.Rotor5, RotorNumber.Rotor3, RotorNumber.Rotor1);
            enigmaMachine.SetRotorDials('g', 'j', 'n');
            enigmaMachine.SetPlugboard(plugboardWiring);
            string plainText = "dalliance chatoyant";

            // Act
            string encodedMessage = enigmaMachine.Encode(plainText);

            // Assert
            enigmaMachine.SetRotorDials('g', 'j', 'n');
            Assert.AreEqual("jyssqzldhgqubgkoji", encodedMessage);
            Assert.AreEqual(plainText.Replace(" ", ""), enigmaMachine.Encode(encodedMessage));
        }
        public void EnigmaMachine_ShouldDecodeWord_WithRotors531()
        {
            // Arrange
            var enigmaMachine = new EnigmaMachine();

            enigmaMachine.ChooseRotors(RotorNumber.Rotor5, RotorNumber.Rotor3, RotorNumber.Rotor1);
            enigmaMachine.SetRotorDials('b', 'j', 'n');
            enigmaMachine.SetPlugboard(plugboardWiring);
            string plainText = "dalliance";

            // Act
            string encodedMessage = enigmaMachine.Encode(plainText);

            // Assert
            enigmaMachine.SetRotorDials('b', 'j', 'n');
            Assert.AreEqual("iymhgqkat", encodedMessage);
            Assert.AreEqual(plainText, enigmaMachine.Encode(encodedMessage));
        }
        public void EnigmaMachine_ShouldDecodeWord_WithRotors345()
        {
            // Arrange
            var enigmaMachine = new EnigmaMachine();

            enigmaMachine.ChooseRotors(RotorNumber.Rotor3, RotorNumber.Rotor4, RotorNumber.Rotor5);
            enigmaMachine.SetRotorDials('b', 'c', 'd');
            enigmaMachine.SetPlugboard(plugboardWiring);
            string plainText = "cynosure";

            // Act
            string encodedMessage = enigmaMachine.Encode(plainText);

            // Assert
            enigmaMachine.SetRotorDials('b', 'c', 'd');
            Assert.AreEqual("oswemtyt", encodedMessage);
            Assert.AreEqual(plainText, enigmaMachine.Encode(encodedMessage));
        }
        public void EnigmaMachine_ShouldDecodeWord_WithRotors234()
        {
            // Arrange
            var enigmaMachine = new EnigmaMachine();

            enigmaMachine.ChooseRotors(RotorNumber.Rotor2, RotorNumber.Rotor3, RotorNumber.Rotor4);
            enigmaMachine.SetRotorDials('a', 'b', 'c');
            enigmaMachine.SetPlugboard(plugboardWiring);
            string plainText = "bungalow";

            // Act
            string encodedMessage = enigmaMachine.Encode(plainText);

            // Assert
            enigmaMachine.SetRotorDials('a', 'b', 'c');
            Assert.AreEqual("noavbjhg", encodedMessage);
            Assert.AreEqual(plainText, enigmaMachine.Encode(encodedMessage));
        }
        public void EnigmaMachine_ShouldDecodeWordWithCapsAndSpaces_WithRotors123()
        {
            // Arrange
            var enigmaMachine = new EnigmaMachine();

            enigmaMachine.ChooseRotors(RotorNumber.Rotor1, RotorNumber.Rotor2, RotorNumber.Rotor3);
            enigmaMachine.SetRotorDials('a', 'a', 'z');
            enigmaMachine.SetPlugboard(plugboardWiring);
            string plainText = "They call Me Mr Tibbs";

            // Act
            string encodedMessage = enigmaMachine.Encode(plainText);

            // Assert
            enigmaMachine.SetRotorDials('a', 'a', 'z');
            Assert.AreEqual("gdjwbtngooygonlym", encodedMessage);
            Assert.AreEqual(plainText.ToLower().Replace(" ", ""), enigmaMachine.Encode(encodedMessage));
        }
Esempio n. 10
0
        public HttpResponseMessage ChooseRotors([FromUri] string rotors)
        {
            HttpResponseMessage message;

            try
            {
                if (rotors.Length != 3)
                {
                    throw new Exception("must indicate 3 rotors");
                }

                if (!Int32.TryParse(rotors.Substring(0, 1), out int firstRotor))
                {
                    throw new Exception("Cound not parse first rotor");
                }

                if (!Int32.TryParse(rotors.Substring(1, 1), out int secondRotor))
                {
                    throw new Exception("Cound not parse second rotor");
                }

                if (!Int32.TryParse(rotors.Substring(2, 1), out int thirdRotor))
                {
                    throw new Exception("Cound not parse third rotor");
                }

                staticEnigmaMachine.ChooseRotors((RotorNumber)firstRotor, (RotorNumber)secondRotor, (RotorNumber)thirdRotor);
                message = Request.CreateResponse(HttpStatusCode.OK);
            }
            catch (Exception ex)
            {
                message = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message);
            }

            return(message);
        }