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 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));
        }
        static void Main(string[] args)
        {
            EnigmaMachine enigmaMachine = new EnigmaMachine();

            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');
            Console.WriteLine(enigmaMachine.Encode("hello"));
        }
Esempio n. 10
0
        public HttpResponseMessage EncryptStatic([FromBody] string text)
        {
            HttpResponseMessage message;

            try
            {
                string encodedText = staticEnigmaMachine.Encode(text);
                message = Request.CreateResponse(HttpStatusCode.OK, encodedText);
            }
            catch (Exception ex)
            {
                message = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex);
            }

            return(message);
        }
        public void EnimagmaMachine_ShouldEncodeWord_When()
        {
            // Arrange

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

            // Assert
            Assert.AreEqual("lbabg", encodedMessage);
        }