public void SetRotorsEnforcesReflector()
{
EnigmaI enigma = new EnigmaI();
EnigmaRotor[] rotors = new EnigmaRotor[4];
enigma.SetRotors(rotors);
}
public void Rotor_IsInTurnoverPosition_True()
{
EnigmaRotor Rotor_I = CreateRotorI();
Rotor_I.SetOffset('Q');
Assert.IsTrue(Rotor_I.IsInTurnoverPosition);
}
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);
}
public void ConstructTest_ReflectorBThin()
{
string expectedMapping = "ENKQAUYWJICOPBLMDXZVFTHRGS";
RotorFactory factory = new RotorFactory();
EnigmaRotor reflector = factory.GetReflector(Reflector.BThin);
Assert.AreEqual(expectedMapping, reflector.Mapping);
}
public void ConstructTest_ReflectorC()
{
string expectedMapping = "FVPJIAOYEDRZXWGCTKUQSBNMHL";
RotorFactory factory = new RotorFactory();
EnigmaRotor reflector = factory.GetReflector(Reflector.C);
Assert.AreEqual(expectedMapping, reflector.Mapping);
}
public void ConstructTest_ReflectorB()
{
string expectedMapping = "YRUHQSLDPXNGOKMIEBFZCWVJAT";
RotorFactory factory = new RotorFactory();
EnigmaRotor reflector = factory.GetReflector(Reflector.B);
Assert.AreEqual(expectedMapping, reflector.Mapping);
}
public void ConstructTest_ReflectorA()
{
string expectedMapping = "EJMZALYXVBWFCRQUONTSPIKHGD";
RotorFactory factory = new RotorFactory();
EnigmaRotor reflector = factory.GetReflector(Reflector.A);
Assert.AreEqual(expectedMapping, reflector.Mapping);
}
public void ConstructTest_ReflectorCThin()
{
string expectedMapping = "RDOBJNTKVEHMLFCWZAXGYIPSUQ";
RotorFactory factory = new RotorFactory();
EnigmaRotor reflector = factory.GetReflector(Reflector.CThin);
Assert.AreEqual(expectedMapping, reflector.Mapping);
}
public static EnigmaRotor CreateAlphabeticalRotor()
{
EnigmaRotor rotor = new EnigmaRotor("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
rotor.SetOffset('A');
rotor.SetTurnover('Y');
return(rotor);
}
public void CanSetRotors()
{
EnigmaI enigma = new EnigmaI();
EnigmaRotor[] rotors = new EnigmaRotor[4];
rotors[0] = new EnigmaReflector();
enigma.SetRotors(rotors);
}
public void Rotor_ReverseMappslettersWithOffsetZero()
{
char expected = 'A';
EnigmaRotor Rotor_I = CreateRotorI();
char actual = Rotor_I.ReverseConvert('E');
Assert.AreEqual(expected, actual);
}
public void SetRotorsEnforcesRotorCount()
{
EnigmaI enigma = new EnigmaI();
EnigmaRotor[] rotors = new EnigmaRotor[3];
rotors[0] = new EnigmaReflector();
enigma.SetRotors(rotors);
}
private static EnigmaRotor CreateRotorI()
{
EnigmaRotor rotorI = new EnigmaRotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ");
rotorI.SetOffset('A');
rotorI.SetTurnover('Q');
return(rotorI);
}
public void Rotor_MapsLettersWithOffsetZero()
{
char expected = 'E';
EnigmaRotor Rotor_I = CreateRotorI();
char actual = Rotor_I.Convert('A');
Assert.AreEqual(expected, actual);
}
public void Rotor_ReverseMapsLettersWithOffset27()
{
char expected = 'D';
EnigmaRotor Rotor_I = CreateRotorI();
Rotor_I.Advance(27);
char actual = Rotor_I.ReverseConvert('K');
Assert.AreEqual(expected, actual);
}
public void Rotor_ReverseMappslettersWithRingSetting()
{
char expected = 'A';
EnigmaRotor Rotor_I = CreateRotorI();
Rotor_I.SetRingSetting('B');
char actual = Rotor_I.ReverseConvert('K');
Assert.AreEqual(expected, actual);
}
private EnigmaRotor[] MergeReflectorIntoRotorArray(Reflector reflector, Rotor[] rotors)
{
EnigmaRotor[] allRotors = new EnigmaRotor[rotors.Length + 1];
allRotors[0] = _rotorFactory.GetReflector(reflector);
for (int i = 0; i < rotors.Length; i++)
{
allRotors[i + 1] = _rotorFactory.GetRotor(rotors[i]);
}
return(allRotors);
}
public void Rotor_SetRingSetting()
{
char expected = 'K';
EnigmaRotor Rotor_I = CreateRotorI();
Rotor_I.SetRingSetting('B');
char actual = Rotor_I.Convert('A');
Assert.AreEqual(expected, actual);
}
public void Rotor_MappslettersWithRingSettingAndOffset()
{
char expected = 'W';
EnigmaRotor Rotor_I = CreateRotorI();
Rotor_I.SetRingSetting('F');
Rotor_I.SetOffset('Y');
char actual = Rotor_I.Convert('A');
Assert.AreEqual(expected, actual);
}
public void ConstructTest_RotorII()
{
string expectedMapping = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
char expectedTurnover = 'E';
RotorFactory factory = new RotorFactory();
EnigmaRotor result = factory.GetRotor(Rotor.II);
Assert.AreEqual(expectedMapping, result.Mapping);
result.SetOffset(expectedTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
}
public void ConstructTest_RotorV()
{
string expectedMapping = "VZBRGITYUPSDNHLXAWMJQOFECK";
char expectedTurnover = 'Z';
RotorFactory factory = new RotorFactory();
EnigmaRotor result = factory.GetRotor(Rotor.V);
Assert.AreEqual(expectedMapping, result.Mapping);
result.SetOffset(expectedTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
}
public void ConstructTest_RotorIV()
{
string expectedMapping = "ESOVPZJAYQUIRHXLNFTGKDCMWB";
char expectedTurnover = 'J';
RotorFactory factory = new RotorFactory();
EnigmaRotor result = factory.GetRotor(Rotor.IV);
Assert.AreEqual(expectedMapping, result.Mapping);
result.SetOffset(expectedTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
}
public void ConstructTest_RotorIII()
{
string expectedMapping = "BDFHJLCPRTXVZNYEIWGAKMUSQO";
char expectedTurnover = 'V';
RotorFactory factory = new RotorFactory();
EnigmaRotor result = factory.GetRotor(Rotor.III);
Assert.AreEqual(expectedMapping, result.Mapping);
result.SetOffset(expectedTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
}
public void ConstructTest_RotorI()
{
string expectedMapping = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
char expectedTurnover = 'Q';
RotorFactory factory = new RotorFactory();
EnigmaRotor result = factory.GetRotor(Rotor.I);
Assert.AreEqual(expectedMapping, result.Mapping);
result.SetOffset(expectedTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
}
public void MultiTurnoversTriggerOnARotor()
{
EnigmaRotor rotorI = new EnigmaRotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ");
rotorI.SetTurnover(new char[] { 'Q', 'S' });
rotorI.SetOffset('Q');
bool firstTurnoverWorks = rotorI.IsInTurnoverPosition;
rotorI.SetOffset('S');
bool secondTurnoverWorks = rotorI.IsInTurnoverPosition;
Assert.IsTrue(firstTurnoverWorks && secondTurnoverWorks);
}
public void ConstructTest_RotorVI()
{
string expectedMapping = "JPGVOUMFYQBENHZRDKASXLICTW";
char firstTurnover = 'Z';
char secondTurnover = 'M';
RotorFactory factory = new RotorFactory();
EnigmaRotor result = factory.GetRotor(Rotor.VI);
Assert.AreEqual(expectedMapping, result.Mapping);
result.SetOffset(firstTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
result.SetOffset(secondTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
}
public void ConstructTest_RotorVII()
{
string expectedMapping = "NZJHGRCXMYSWBOUFAIVLPEKQDT";
char firstTurnover = 'Z';
char secondTurnover = 'M';
RotorFactory factory = new RotorFactory();
EnigmaRotor result = factory.GetRotor(Rotor.VII);
Assert.AreEqual(expectedMapping, result.Mapping);
result.SetOffset(firstTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
result.SetOffset(secondTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
}
public void ConstructTest_RotorVIII()
{
string expectedMapping = "FKQHTLXOCBJSPDZRAMEWNIUYGV";
char firstTurnover = 'Z';
char secondTurnover = 'M';
RotorFactory factory = new RotorFactory();
EnigmaRotor result = factory.GetRotor(Rotor.VIII);
Assert.AreEqual(expectedMapping, result.Mapping);
result.SetOffset(firstTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
result.SetOffset(secondTurnover);
Assert.IsTrue(result.IsInTurnoverPosition);
}
private static EnigmaRotor[] BuildRotorArray()
{
EnigmaRotor rotorI = EnigmaIMachineTestSupport.CreateRotorI();
EnigmaRotor rotorII = EnigmaIMachineTestSupport.CreateRotorII();
EnigmaRotor rotorIII = EnigmaIMachineTestSupport.CreateRotorIII();
EnigmaReflector reflectorB = EnigmaIMachineTestSupport.CreateBReflector();
EnigmaRotor[] rotors = new EnigmaRotor[4];
rotors[0] = reflectorB;
rotors[1] = rotorI;
rotors[2] = rotorII;
rotors[3] = rotorIII;
return(rotors);
}
public void Rotor_CanSetTurnoverArray()
{
EnigmaRotor rotorI = new EnigmaRotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ");
rotorI.SetTurnover(new char[] { 'Q', 'S' });
}
