TDD-Deciphered.com

<?php
require_once('../../library/initialise.php');
 
class Enigma_SteckerBoardTest extends PHPUnit_Framework_TestCase
{
    /**
     * Test various stecker combinations, swapped and non-swapped characters
     * @dataProvider steckerSwapsDataProvider
     * @param $steckers Array pairs of letters
     * @param $in String single character
     * @param $out String single character
     * @return null
     */
    function testSubstitutions($steckers, $in, $out)
    {
        $steckerBoard=new Enigma_SteckerBoard();
        $steckerBoard->setSteckers($steckers);
 
        $this->assertSame(
            $out,
            $steckerBoard->getOutputCharacterForInputCharacter($in),
            "Stecker must substitute pair as specified"
        );
        $this->assertSame(
            $in,
            $steckerBoard->getOutputCharacterForInputCharacter($out),
            "Stecker substitution must be reciprocal"
        );
    }
 
    function steckerSwapsDataProvider()
    {
        $testData=array(
            array(array(),'A','A'), // Test identity mapping with no steckers plugged
            array(
                array(
                    'D'=>'N','G'=>'R','I'=>'S','K'=>'C','Q'=>'X',
                    'T'=>'M','P'=>'V','H'=>'Y','F'=>'W','B'=>'J'
                ),
                'K',
                'C',
            ),
            array(
                array(
                    'D'=>'N','G'=>'R','I'=>'S','K'=>'C','Q'=>'X',
                    'T'=>'M','P'=>'V','H'=>'Y','F'=>'W','B'=>'J'
                ),
                'E',
                'E',
            ),
            array(
                array('A'=>'T','B'=>'L','D'=>'F','G'=>'J','H'=>'M','N'=>'W',),'H','M',
            ),
            array(
                array('A'=>'T','B'=>'L','D'=>'F','G'=>'J','H'=>'M','N'=>'W',),'C','C',
            )
        );
 
        return ($testData);
    }

<?php
class Enigma_SteckerBoard implements Enigma_Encryptor_Interface
{
    protected $_steckers=array();
 
    public function clearAllSteckers()
    {
        $this->_steckers=array();
    }
 
    public function setStecker($from,$to)
    {
        if(!(preg_match('/^[A-Z]$/',$from) && preg_match('/^[A-Z]$/',$to))) {
            throw new Exception("Invalid stecker pair $from-$to");
        }
 
        if(isset($_this->_steckers[$from])) {
            throw new Exception("Stecker socket $from already used");
        }
 
        if(isset($_this->_steckers[$to])) {
            throw new Exception("Stecker socket $to already used");
        }
 
        $this->_steckers[$from]=$to;
        $this->_steckers[$to]=$from;
    }
 
    public function setSteckers($assocArray)
    {
        $this->clearAllSteckers();
 
        foreach($assocArray as $from=>$to)
        {
            $this->setStecker($from,$to);
        }
    }
 
    public function getOutputCharacterForInputCharacter ($inputCharacter)
    {
        if(isset($this->_steckers[$inputCharacter])) {
            $char=$this->_steckers[$inputCharacter];
        } else {
            $char=$inputCharacter;
        }
 
        return $char;
    }
 
}

/**
     * Constructor
     *
     * @param $numSlots integer Number of Rotor slots
     * @param $hasSteckerBoard boolean Does this machine have a steckerboard
     * @return null
     */
    public function __construct($numSlots=3, $hasSteckerBoard=true)
    {
        if(($numSlots<1) || !is_integer($numSlots)) {
            throw new Exception('Number of slots must be positive integer');
        }
 
        if(!is_bool($hasSteckerBoard)) {
            throw new Exception('Steckerboard flag must be boolean');
        }
 
        $this->_numSlots=$numSlots;
        $this->_hasSteckerBoard=$hasSteckerBoard;
 
        if($this->_hasSteckerBoard)
        {   // Can implement this later!
            $this->_steckerBoard=new Enigma_SteckerBoard;
        }
 
        for($i=0; $i<$this->_numSlots; $i++) {
            $this->_slots[$i]=new Enigma_RotorSlot;
            if($i>0) { //higher slots watch lower ones
                $this->_slots[$i-1]->registerTurnoverObserver($this->_slots[$i]);
            }
        }
    }

<?php
require_once ('../library/initialise.php');
 
$messageString='NCZW VUSX PNYM INHZ XMQX
 SFWX WLKJ AHSH NMCO CCAK
 UQPM KCSM HKSE INJU SBLK
 IOSX CKUB HMLL XCSJ USRR
 DVKO HULX WCCB GVLI YXEO
 AHXR HKKF VDRE WEZL XOBA
 FGYU JQUK GRTV UKAM EURB
 VEKS UHHV OYHA BCJW MAKL
 FKLM YFVN RIZR VVRT KOFD
 ANJM OLBG FFLE OPRG TFLV
 RHOW OPBE KVWM UQFM PWPA
 RMFH AGKX IIBG
';
 
$messageArray=preg_split('//',$messageString);
//var_dump($messageArray);
 
$messageArrayClean=array();
foreach($messageArray as $char) {
    if(preg_match('/[a-z]/i',$char)) {
        $messageArrayClean[]=strtoupper($char);
    }
}
 
$steckers=array('A'=>'T','B'=>'L','D'=>'F','G'=>'J','H'=>'M',
        'N'=>'W','O'=>'P','Q'=>'Y','R'=>'Z','V'=>'X');
 
$device=new Enigma_Machine(4,true);
 
$rotors=array();
$rotors[0]=new Enigma_Rotor_I;
$rotors[0]->setRingOffset('V');
$rotors[1]=new Enigma_Rotor_IV;
$rotors[1]->setRingOffset('A');
$rotors[2]=new Enigma_Rotor_II;
$rotors[2]->setRingOffset('A');
$rotors[3]=new Enigma_Rotor_Beta;
$rotors[3]->setRingOffset('A');
 
$device->setRotors($rotors);
$device->setRotorStartPositions(array('A','N','J','V'));
 
$reflector=new Enigma_Reflector_Bdunn;
 
$device->setReflector($reflector);
 
$device->getSteckerBoard()->setSteckers($steckers);
 
echo ("\n".join('',$messageArrayClean)."\n\n");
 
foreach ($messageArrayClean as $char)
{
        $char=$device->getOutputCharacterForInputCharacter($char);
 
        echo $char;
}
echo ("\n\n");

silverbox:cli wechsler$ php -q m4TestRigWithDeviceAndSteckers.php 

NCZWVUSXPNYMINHZXMQXSFWXWLKJAHSHNMCOCCAKUQPMKCSMHKSEINJUSBLKIOSXCKUBHMLLXCSJUSRRDVKOHULXWCCBGVLIYXEOAHXRHKKFVDREWEZLXOBAFGYUJQUKGRTVUKAMEURBVEKSUHHVOYHABCJWMAKLFKLMYFVNRIZRVVRTKOFDANJMOLBGFFLEOPRGTFLVRHOWOPBEKVWMUQFMPWPARMFHAGKXIIBG

VONVONJLOOKSJHFFTTTEINSEINSDREIZWOYYQNNSNEUNINHALTXXBEIANGRIFFUNTERWASSERGEDRUECKTYWABOSXLETZTERGEGNERSTANDNULACHTDREINULUHRMARQUANTONJOTANEUNACHTSEYHSDREIYZWOZWONULGRADYACHTSMYSTOSSENACHXEKNSVIERMBFAELLTYNNNNNNOOOVIERYSICHTEINSNULL