public void Plugboard_InitializedWithStaticFactoryConstructor_NoConfigurationSet()
{
var plugboard = Plugboard.Default();
plugboard.PlugCableConfiguration.Should()
.BeEmpty();
}
public void Plugboard_InitializedWithStaticFactory_NotNull()
{
var plugboard = Plugboard.Default();
plugboard.Should()
.NotBeNull();
}
public void CheckU264Message()
{
string expectedPlainText = "VONVONJLOOKSJHFFTTTEINSEINSDREIZWOYYQNNSNEUNINHALTXXBEIANGRIFFUNTERWASSERGEDRUECKTYWABOSXLETZTERGEGNERSTANDNULACHTDREINULUHRMARQUANTONJOTANEUNACHTSEYHSDREIYZWOZWONULGRADYACHTSMYSTOSSENACHXEKNSVIERMBFAELLTYNNNNNNOOOVIERYSICHTEINSNULL";
// Message Key: VJNA
// Reflector: Thin B
// Wheel order: Beta II IV I
// Ring positions: 01 01 01 22
// Plug Pairs: AT BL DF GJ HM NW OP QY RZ VX
Scrambler4 s = new Scrambler4(Reflector.ReflectorThinB(), Rotor.RotorBeta((Letters)0, Letters.V), Rotor.RotorII((Letters)0, Letters.J), Rotor.RotorIV((Letters)0, Letters.N), Rotor.RotorI((Letters)21, Letters.A));
Plugboard p = new Plugboard(new Dictionary <Letters, Letters>
{
{ Letters.A, Letters.T },
{ Letters.B, Letters.L },
{ Letters.D, Letters.F },
{ Letters.G, Letters.J },
{ Letters.H, Letters.M },
{ Letters.N, Letters.W },
{ Letters.O, Letters.P },
{ Letters.Q, Letters.Y },
{ Letters.R, Letters.Z },
{ Letters.V, Letters.X },
});
EnigmaM4 e = new EnigmaM4(s, p);
string cypherText = "NCZWVUSXPNYMINHZXMQXSFWXWLKJAHSHNMCOCCAKUQPMKCSMHKSEINJUSBLKIOSXCKUBHMLLXCSJUSRRDVKOHULXWCCBGVLIYXEOAHXRHKKFVDREWEZLXOBAFGYUJQUKGRTVUKAMEURBVEKSUHHVOYHABCJWMAKLFKLMYFVNRIZRVVRTKOFDANJMOLBGFFLEOPRGTFLVRHOWOPBEKVWMUQFMPWPARMFHAGKXIIBG";
string plainText = e.GetOutput(cypherText);
Assert.That(plainText, Is.EqualTo(expectedPlainText));
}
public void CheckOperationBarbarosaMessage()
{
string expectedPlainText = "AUFKLXABTEILUNGXVONXKURTINOWAXKURTINOWAXNORDWESTLXSEBEZXSEBEZXUAFFLIEGERSTRASZERIQTUNGXDUBROWKIXDUBROWKIXOPOTSCHKAXOPOTSCHKAXUMXEINSAQTDREINULLXUHRANGETRETENXANGRIFFXINFXRGTX";
// Message Key: BLA
// Reflector: B
// Wheel order: II IV V
// Ring positions: 02 21 12
// Plug Pairs: AV BS CG DL FU HZ IN KM OW RX
Scrambler3 s = new Scrambler3(Reflector.ReflectorB(), Rotor.RotorII((Letters)1, Letters.B), Rotor.RotorIV((Letters)20, Letters.L), Rotor.RotorV((Letters)11, Letters.A));
Plugboard p = new Plugboard(new Dictionary <Letters, Letters>
{
{ Letters.A, Letters.V },
{ Letters.B, Letters.S },
{ Letters.C, Letters.G },
{ Letters.D, Letters.L },
{ Letters.F, Letters.U },
{ Letters.H, Letters.Z },
{ Letters.I, Letters.N },
{ Letters.K, Letters.M },
{ Letters.O, Letters.W },
{ Letters.R, Letters.X },
});
EnigmaM3 e = new EnigmaM3(s, p);
string cypherText = "EDPUDNRGYSZRCXNUYTPOMRMBOFKTBZREZKMLXLVEFGUEYSIOZVEQMIKUBPMMYLKLTTDEISMDICAGYKUACTCDOMOHWXMUUIAUBSTSLRNBZSZWNRFXWFYSSXJZVIJHIDISHPRKLKAYUPADTXQSPINQMATLPIFSVKDASCTACDPBOPVHJK";
string plainText = e.GetOutput(cypherText);
Assert.That(plainText, Is.EqualTo(expectedPlainText));
}
public void Plugboard_InitializedWithConstructor_NotNull()
{
var plugboard = new Plugboard();
plugboard.Should()
.NotBeNull();
}
public void CheckInstructionManualMessage()
{
string expectedPlainText = "FEINDLIQEINFANTERIEKOLONNEBEOBAQTETXANFANGSUEDAUSGANGBAERWALDEXENDEDREIKMOSTWAERTSNEUSTADT";
// Message Key: ABL
// Reflector: A
// Wheel order: II I III
// Ring positions: 24 13 22
// Plug Pairs: AM FI NV PS TU WZ
Scrambler3 s = new Scrambler3(Reflector.ReflectorA(), Rotor.RotorII((Letters)23, Letters.A), Rotor.RotorI((Letters)12, Letters.B), Rotor.RotorIII((Letters)21, Letters.L));
Plugboard p = new Plugboard(new Dictionary <Letters, Letters>
{
{ Letters.A, Letters.M },
{ Letters.F, Letters.I },
{ Letters.N, Letters.V },
{ Letters.P, Letters.S },
{ Letters.T, Letters.U },
{ Letters.W, Letters.Z },
});
EnigmaM3 e = new EnigmaM3(s, p);
string cypherText = "GCDSEAHUGWTQGRKVLFGXUCALXVYMIGMMNMFDXTGNVHVRMMEVOUYFZSLRHDRRXFJWCFHUHMUNZEFRDISIKBGPMYVXUZ";
string plainText = e.GetOutput(cypherText);
Assert.That(plainText, Is.EqualTo(expectedPlainText));
}
static void Main(string[] args)
{
Rotor rL = new Rotor(FixedMechanicRotor.ROTOR_II); //II has notch F
Rotor rM = new Rotor(FixedMechanicRotor.ROTOR_IV); //IV has notch K
Rotor rR = new Rotor(FixedMechanicRotor.ROTOR_V); //V has notch A
//Following WW2 Convention, it is Left-Mid-Right e.g. II IV V
Rotor[] rotors = { rL, rM, rR };
Reflector re = new Reflector(FixedMechanicReflector.REFLECTOR_B);
Plugboard plug = new Plugboard(new String[] {
"AV", "BS", "CG", "DL", "FU", "HZ", "IN", "KM", "OW", "RX"}); //Barbarosa
WindowSetting initialSetting = new WindowSetting('B', 'L', 'A');
RingSetting ringPositions = new RingSetting(2, 21, 12);
//an example of naming hassle because Enigma is both namespace and class
Enigma.representation.Enigma enigma = new Enigma.representation.Enigma(rotors, re, plug, ringPositions, initialSetting);
string myfile = "C:\\Users\\ToshiW\\Documents\\Visual Studio 2012\\Projects\\Enigma\\Enigma\\Resources\\BarbarosaCiphertext.txt";
string input = Utility.FileToString(myfile);
//Console.WriteLine(readResult);
//Console.ReadLine();
//Let Enigma do its thing
string result = enigma.encryptString(input);
Console.WriteLine(result);
Console.ReadLine();
}
public void ValidConstruction()
{
var pb = new Plugboard("AB");
Assert.AreEqual('B', pb.process('A'), "A has to be translated to B with 'AB'");
Assert.AreEqual('A', pb.process('B'), "B has to be translated to A with 'AB'");
Assert.AreEqual('C', pb.process('C'), "C has to stay C with 'AB'");
}
public EnigmaMachine()
{
_plugboard = new Plugboard();
_fastRotor = new RotorSocket(Rotor.Create(RotorVariation.FirstTypeRotor));
_middleRotor = new RotorSocket(Rotor.Create(RotorVariation.SecondTypeRotor));
_slowRotor = new RotorSocket(Rotor.Create(RotorVariation.ThirdTypeRotor));
_reflector = new RotorSocket(Reflector.Create(ReflectorVariation.FirstTypeReflector));
}
public void TestConnections()
{
var plugboard = new Plugboard("ABCKEFGHIJDLNMOPQRSTUZWXYV");
var rightLeftMappings = AlphabetLetters.Select(c => plugboard.GetMappedLetter(c)).ToArray();
var leftRightMappings = rightLeftMappings.Select(c => plugboard.GetMappedLetter(c, LetterMapper.MappingDirection.LeftToRight)).ToArray();
Assert.IsTrue(AlphabetLetters.Zip(leftRightMappings, (c1, c2) => c1 == c2).All(res => res));
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="plugboard">Plugboard.</param>
/// <param name="left">Left rotor.</param>
/// <param name="center">Center rotor.</param>
/// <param name="right">Right rotor.</param>
/// <param name="reflector">Reflector.</param>
public Enigma(Plugboard plugboard, Rotor left, Rotor center, Rotor right, Reflector reflector)
{
_plugboard = plugboard;
_left = left;
_right = right;
_center = center;
_reflector = reflector;
}
public void Plugboard_InitializedWithConfiguration_ConfigurationSet()
{
var plugCableConfiguration = MockData.plugboardTestConfiguration1;
var plugboard = new Plugboard(plugCableConfiguration);
plugboard.PlugCableConfiguration.Should()
.BeEquivalentTo(plugCableConfiguration);
}
public void Plugboard_UnknownKeyEntered_ArgumentExceptionRaised()
{
var plugboard = new Plugboard();
Action act = () => plugboard.ProcessKey(Key.Unknown);
act.Should()
.Throw <ArgumentException>();
}
public void Plugboard_PlugCableConfigurationReset_ConfigurationCleared()
{
var plugboard = new Plugboard(MockData.plugboardTestConfiguration1);
plugboard.ResetPlugCableConfiguration();
plugboard.PlugCableConfiguration.Should()
.BeEmpty();
}
public void Plugboard_PlugCableConfigurationSet_ConfigurationSet()
{
var plugboard = new Plugboard();
plugboard.SetPlugCableConfiguration(MockData.plugboardTestConfiguration1);
plugboard.PlugCableConfiguration.Should()
.BeEquivalentTo(MockData.plugboardTestConfiguration1);
}
public void Plugboard_NullPlugCableConfigurationSet_ArgumentNullException()
{
var plugboard = new Plugboard();
Action act = () => plugboard.SetPlugCableConfiguration(null);
act.Should()
.Throw <ArgumentNullException>();
}
public void PlugboardNotConfigured_KeyEntered_KeyEnteredTriggersEvent()
{
var plugboard = new Plugboard();
var keyPressed = Key.A;
var newKey = plugboard.ProcessKey(keyPressed);
newKey.Should()
.Be(keyPressed);
}
public void CheckPlugboardReturnsCorrectForUnmapped()
{
Plugboard p = new Plugboard(new Dictionary <Letters, Letters> {
{ Letters.A, Letters.B }
});
Letters result = p.GetOutput(Letters.C);
Assert.That(result, Is.EqualTo(Letters.C));
}
public void ConvertLetter_ShouldReturnLetter_WhenKeyDoesntExists()
{
// Arrange
Plugboard plugboard = new Plugboard();
plugboard.SetWiring('a', 'k');
// Assert
Assert.AreEqual('f', plugboard.ConvertLetter('f'));
}
public void TestNoConnection()
{
var plugboard = new Plugboard();
var rightLeftMappings = AlphabetLetters.Select(c => plugboard.GetMappedLetter(c)).ToArray();
var leftRightMappings = AlphabetLetters.Select(c => plugboard.GetMappedLetter(c, LetterMapper.MappingDirection.LeftToRight)).ToArray();
Assert.IsTrue(rightLeftMappings.Zip(leftRightMappings, (c1, c2) => c1 == c2).All(res => res));
Assert.IsTrue(rightLeftMappings.Zip(AlphabetLetters, (c1, c2) => c1 == c2).All(res => res));
}
public void Plugboard_PlugCableAddedToConfiguration_ConfigurationChanged(Key key1, Key key2)
{
var plugboard = new Plugboard();
var plugCable = new PlugCable(key1, key2);
plugboard.InsertPlugCable(plugCable);
plugboard.PlugCableConfiguration.Should()
.Contain(plugCable).And
.HaveCount(1);
}
public void KeyboardWithPlugboard_KeyPressedNoConfiguration_KeyReturned(Key keyPressed)
{
var plugboard = new Plugboard();
var keyboard = new Keyboard(plugboard);
using var monitoredSubject = keyboard.Monitor();
keyboard.OnKeyPressed(keyPressed);
monitoredSubject.Should()
.Raise(nameof(IKeyboard.KeyProvidedEvent))
.WithArgs <KeyPressedEventArgs>(x => x.KeyPressed == keyPressed);
}
public void Plugboard_AddPlugCableAlreadyAdded_ExceptionRaised()
{
var configuration = new List <PlugCable> {
MockData.testPlugCableDifferentKeys1
};
var plugboard = new Plugboard(configuration);
Action act = () => plugboard.InsertPlugCable(MockData.testPlugCableDifferentKeys1);
act.Should()
.Throw <PlugboardConfigurationException>();
}
public void SetWiring_ShouldSetCountTo2_WhenAddingOnePair()
{
// Arrange
Plugboard plugboard = new Plugboard();
// Act
plugboard.SetWiring('a', 'h');
var wiring = plugboard.GetWiring();
// Assert
Assert.AreEqual(2, wiring.Count);
}
public void PlugboardConfigured_KeyEntered_KeyEnteredTriggersEvent(Key plugA, Key plugB, Key keyEntered, Key keyReturned)
{
var configuration = new List <PlugCable>()
{
new PlugCable(plugA, plugB)
};
var plugboard = new Plugboard(configuration);
var newKey = plugboard.ProcessKey(keyEntered);
newKey.Should()
.Be(keyReturned);
}
public void RemoveWiring_ShouldThrow_IfSettingLessThan0()
{
// Arrange
Plugboard plugboard = new Plugboard();
int initNumPairs = plugboard.NumberPairs;
// Act
plugboard.RemoveWiring('a', 'b');
//Assert.ThrowsException<ArgumentException>( () => plugboard.RemoveWiring('a'));
// Assert
Assert.IsTrue(0 == plugboard.NumberPairs);
}
public void RemoveWiring_ShouldThrow_IfKeyDoesntExist()
{
// Arrange
Plugboard plugboard = new Plugboard();
plugboard.SetWiring('b', 'x');
// Act Assert
plugboard.RemoveWiring('c', 'x');
// Assert
Assert.IsTrue(2 == plugboard.GetWiring().Count);
}
public void SetWiring_ShouldAdd1Wiring_WhenDuplicateKey()
{
// Arrange
Plugboard plugboard = new Plugboard();
// Act
plugboard.SetWiring('a', 'h');
plugboard.SetWiring('a', 'i');
var wiring = plugboard.GetWiring();
// Assert
Assert.AreEqual(2, wiring.Count);
Assert.AreEqual('i', wiring['a']);
}
public void Plugboard_AddPlugCableKeyAlreadyConfigured_ExceptionRaised()
{
var plugCable1 = new PlugCable(Key.A, Key.C);
var plugCable2 = new PlugCable(Key.A, Key.D);
var configuration = new List <PlugCable> {
plugCable1
};
var plugboard = new Plugboard(configuration);
Action act = () => plugboard.InsertPlugCable(plugCable2);
act.Should()
.Throw <PlugboardConfigurationException>();
}
public void SetWiring_ShouldOnlyHaveCount2_WhenAddingDuplicateWireEndpont()
{
// Arrange
Plugboard plugboard = new Plugboard();
// Act
plugboard.SetWiring('a', 'h');
plugboard.SetWiring('a', 'i');
var wiring = plugboard.GetWiring();
// Assert
Assert.AreEqual(2, wiring.Count);
Assert.AreEqual('i', wiring['a']);
}
public void TranslateEnigmaMessage()
{
var wireConfig = "ABCDEFGHIJZYXWVUTSRQ";
var pb = new Plugboard(wireConfig);
var plain = "THE ENIGMA MACHINE CANNOT BE CRACKED";
var expected = "SGF FNJHMB MBDGJNF DBNNOS AF DQBDKFC";
var encrypted = plain.Select(c => pb.process(c));
Assert.AreEqual(expected, encrypted, "Invalid encryption for '" + wireConfig + '"');
var decrypted = encrypted.Select(c => pb.process(c));
Assert.AreEqual(plain, decrypted, "Invalid encryption for '" + wireConfig + '"');
}
