private static NestedEnigmaMachine BuildEnigma(char[] ringSettings = null)
{
if (ringSettings == null)
{
ringSettings = new char[] { 'A', 'A', 'A' };
}
NestedRotor rotorI = NestedEnigmaMachineTestSupport.CreateRotorI();
rotorI.SetRingSetting(ringSettings[0]);
NestedRotor rotorII = NestedEnigmaMachineTestSupport.CreateRotorII();
rotorII.SetRingSetting(ringSettings[1]);
NestedRotor rotorIII = NestedEnigmaMachineTestSupport.CreateRotorIII();
rotorIII.SetRingSetting(ringSettings[2]);
EnigmaReflector reflectorB = NestedEnigmaMachineTestSupport.CreateBReflector();
NestedEnigmaMachine enigma = new NestedEnigmaMachine();
EnigmaRotor[] rotors = new EnigmaRotor[4];
rotors[0] = reflectorB;
rotors[1] = rotorI;
rotors[2] = rotorII;
rotors[3] = rotorIII;
enigma.SetRotors(rotors);
return(enigma);
}
private static NestedRotor CreateMultiRotorEnigmaMachine(string key)
{
NestedRotor rotorI = new NestedRotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ");
rotorI.SetOffset(key[0]);
rotorI.SetTurnover('Q');
NestedRotor rotorII = new NestedRotor("AJDKSIRUXBLHWTMCQGZNPYFVOE");
rotorII.SetOffset(key[1]);
rotorII.SetTurnover('E');
NestedRotor rotorIII = new NestedRotor("BDFHJLCPRTXVZNYEIWGAKMUSQO");
rotorIII.SetOffset(key[2]);
rotorIII.SetTurnover('V');
EnigmaReflector BReflector = new EnigmaReflector()
{
Mapping = "YRUHQSLDPXNGOKMIEBFZCWVJAT"
};
rotorIII.Drives = rotorII;
rotorII.Drives = rotorI;
rotorI.Drives = BReflector;
return(rotorIII);
}
public static NestedRotor CreateRotorI()
{
NestedRotor rotor = new NestedRotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ");
rotor.SetOffset('A');
rotor.SetTurnover('Q');
return(rotor);
}
public static NestedRotor CreateAlphabeticalRotor()
{
NestedRotor rotor = new NestedRotor("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
rotor.SetOffset('A');
rotor.SetTurnover('Y');
return(rotor);
}
public void GetSingleRotorConfigurationTest()
{
NestedRotor Rotor_I = CreateSingleRotorEnigmaMachine();
string expected = "A";
string actual = Rotor_I.CurrentConfiguration;
Assert.AreEqual(expected, actual);
}
public void TestMethod1()
{
char expected = 'A';
NestedRotor enigma = CreateSingleRotorEnigmaMachine();
char actual = enigma.Crypt('A');
Assert.AreEqual(expected, actual);
}
public void GetMultiRotorConfigurationTest_MultiStepped_RightNormal()
{
NestedRotor Rotor_I = CreateMultiRotorEnigmaMachine("AAU");
string expected = "AAU";
string actual = Rotor_I.CurrentConfiguration;
Assert.AreEqual(expected, actual);
}
public void NestedRotor_ReverseMappslettersWithOffsetZero()
{
char expected = 'A';
NestedRotor Rotor_I = CreateRotorI();
char actual = Rotor_I.ReverseConvert('E');
Assert.AreEqual(expected, actual);
}
public static NestedRotor CreateRotorIII()
{
NestedRotor rotor = new NestedRotor("BDFHJLCPRTXVZNYEIWGAKMUSQO");
rotor.SetOffset('A');
rotor.SetTurnover('V');
return(rotor);
}
public void SingleCharacterDeCrypt()
{
char expected = 'G';
NestedRotor enigma = CreateMultiRotorEnigmaMachine("AAA");
char actual = enigma.Crypt('P');
Assert.AreEqual(expected, actual);
}
public static NestedRotor CreateRotorII()
{
NestedRotor rotor = new NestedRotor("AJDKSIRUXBLHWTMCQGZNPYFVOE");
rotor.SetOffset('A');
rotor.SetTurnover('E');
return(rotor);
}
private static NestedRotor CreateSingleRotorEnigmaMachine()
{
NestedRotor rotorI = new NestedRotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ");
rotorI.SetOffset('A');
rotorI.SetTurnover('Q');
rotorI.Drives = new EnigmaReflector();
return(rotorI);
}
public void NestedRotor_MapsLettersWithOffsetZero()
{
char expected = 'E';
NestedRotor Rotor_I = CreateRotorI();
char actual = Rotor_I.Convert('A');
Assert.AreEqual(expected, actual);
}
public void NestedRotor_SetOffset()
{
char expected = 'J';
NestedRotor Rotor_I = CreateRotorI();
Rotor_I.SetOffset('B');
char actual = Rotor_I.Convert('A');
Assert.AreEqual(expected, actual);
}
public void GetMultiRotorConfigurationTest_Stepped()
{
NestedRotor Rotor_I = CreateMultiRotorEnigmaMachine("AAA");
string expected = "AAB";
Rotor_I.Advance();
string actual = Rotor_I.CurrentConfiguration;
Assert.AreEqual(expected, actual);
}
public void NestedRotor_MappslettersWithRingSetting()
{
char expected = 'K';
NestedRotor Rotor_I = CreateRotorI();
Rotor_I.SetRingSetting('B');
char actual = Rotor_I.Convert('A');
Assert.AreEqual(expected, actual);
}
public void NestedRotor_ReverseMapsLettersWithOffset27()
{
char expected = 'D';
NestedRotor Rotor_I = CreateRotorI();
Rotor_I.Advance(27);
char actual = Rotor_I.ReverseConvert('K');
Assert.AreEqual(expected, actual);
}
private static NestedRotor CreateSingleRotorEnigmaMachine()
{
NestedRotor rotorI = new NestedRotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ");
rotorI.SetOffset('A');
rotorI.SetTurnover('Q');
rotorI.Drives = new EnigmaReflector()
{
Mapping = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
};
return(rotorI);
}
//public EnigmaMachine(NestedRotor rotorI, NestedRotor rotorII, NestedRotor rotorIII, Reflector reflectorB) : this()
//{
// rotorI.Drives = reflectorB;
// rotorII.Drives = rotorI;
// rotorIII.Drives = rotorII;
// _rotors = rotorIII;
//}
public void SetRotors(EnigmaRotor[] rotors)
{
EnigmaReflector reflector = rotors[0] as EnigmaReflector;
var temp = rotors.Skip(1).ToArray();
var nestedRotors = Array.ConvertAll(temp, item => (NestedRotor)item);
for (int i = nestedRotors.Length - 1; i > 0; i--)
{
nestedRotors[i].Drives = nestedRotors[i - 1];
}
nestedRotors[0].Drives = reflector;
_rotors = nestedRotors[nestedRotors.Length - 1];
}
public void NestedRotor_HasMapping()
{
NestedRotor temp = new NestedRotor();
temp.Mapping = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
}
public void CanCreateNestedRotor()
{
NestedRotor temp = new NestedRotor();
}
