muzich/vendor/swiftmailer/tests/unit/Swift/Mime/ContentEncoder/PlainContentEncoderTest.php

<?php

require_once 'Swift/Tests/SwiftUnitTestCase.php';
require_once 'Swift/Mime/ContentEncoder/PlainContentEncoder.php';
require_once 'Swift/InputByteStream.php';
require_once 'Swift/OutputByteStream.php';

class Swift_StreamCollector implements Yay_Action {
  public $content = '';
  public function &invoke(Yay_Invocation $inv) {
    $args = $inv->getArguments();
    $this->content .= current($args);
  }
  public function describeTo(Yay_Description $description) {
    $description->appendText(' gathers input;');
  }
}

class Swift_Mime_ContentEncoder_PlainContentEncoderTest
  extends Swift_Tests_SwiftUnitTestCase
{
  
  public function testNameCanBeSpecifiedInConstructor()
  {
    $encoder = $this->_getEncoder('7bit');
    $this->assertEqual('7bit', $encoder->getName());
    
    $encoder = $this->_getEncoder('8bit');
    $this->assertEqual('8bit', $encoder->getName());
  }
  
  public function testNoOctetsAreModifiedInString()
  {
    $encoder = $this->_getEncoder('7bit');
    foreach (range(0x00, 0xFF) as $octet)
    {
      $byte = pack('C', $octet);
      $this->assertIdenticalBinary($byte, $encoder->encodeString($byte));
    }
  }
  
  public function testNoOctetsAreModifiedInByteStream()
  {
    $encoder = $this->_getEncoder('7bit');
    foreach (range(0x00, 0xFF) as $octet)
    {
      $byte = pack('C', $octet);
      
      $os = $this->_createOutputByteStream();
      $is = $this->_createInputByteStream();
      $collection = new Swift_StreamCollector();

      $this->_checking(Expectations::create()
        -> allowing($is)->write(any(), optional()) -> will($collection)
        -> ignoring($is)
        
        -> one($os)->read(optional()) -> returns($byte)
        -> allowing($os)->read(optional()) -> returns(false)
        
        -> ignoring($os)
        );
      
      $encoder->encodeByteStream($os, $is);
      $this->assertIdenticalBinary($byte, $collection->content);
    }
  }
  
  public function testLineLengthCanBeSpecified()
  {
    $encoder = $this->_getEncoder('7bit');
    
    $chars = array();
    for ($i = 0; $i < 50; $i++)
    {
      $chars[] = 'a';
    }
    $input = implode(' ', $chars); //99 chars long
    
    $this->assertEqual(
      'a a a a a a a a a a a a a a a a a a a a a a a a a ' . "\r\n" . //50 *
      'a a a a a a a a a a a a a a a a a a a a a a a a a',            //99
      $encoder->encodeString($input, 0, 50),
      '%s: Lines should be wrapped at 50 chars'
      );
  }
  
  public function testLineLengthCanBeSpecifiedInByteStream()
  {
    $encoder = $this->_getEncoder('7bit');
    
    $os = $this->_createOutputByteStream();
    $is = $this->_createInputByteStream();
    $collection = new Swift_StreamCollector();
    
    $this->_checking(Expectations::create()
      -> allowing($is)->write(any(), optional()) -> will($collection)
      -> ignoring($is)
      );
    
    for ($i = 0; $i < 50; $i++)
    {
      $this->_checking(Expectations::create()
        -> one($os)->read(optional()) -> returns('a ')
        );
    }
    
    $this->_checking(Expectations::create()
      -> allowing($os)->read(optional()) -> returns(false)
      );
    
    $encoder->encodeByteStream($os, $is, 0, 50);
    $this->assertEqual(
      str_repeat('a ', 25) . "\r\n" . str_repeat('a ', 25),
      $collection->content
      );
  }
  
  public function testencodeStringGeneratesCorrectCrlf()
  {
    $encoder = $this->_getEncoder('7bit', true);
    $this->assertEqual("a\r\nb", $encoder->encodeString("a\rb"),
      '%s: Line endings should be standardized'
      );
    $this->assertEqual("a\r\nb", $encoder->encodeString("a\nb"),
      '%s: Line endings should be standardized'
      );
    $this->assertEqual("a\r\n\r\nb", $encoder->encodeString("a\n\rb"),
      '%s: Line endings should be standardized'
      );
    $this->assertEqual("a\r\n\r\nb", $encoder->encodeString("a\r\rb"),
      '%s: Line endings should be standardized'
      );
    $this->assertEqual("a\r\n\r\nb", $encoder->encodeString("a\n\nb"),
      '%s: Line endings should be standardized'
      );
  }
  
  public function testCanonicEncodeByteStreamGeneratesCorrectCrlf_1()
  {
    $encoder = $this->_getEncoder('7bit', true);
    
    $os = $this->_createOutputByteStream();
    $is = $this->_createInputByteStream();
    $collection = new Swift_StreamCollector();

    $this->_checking(Expectations::create()
      -> allowing($is)->write(any(), optional()) -> will($collection)
      -> ignoring($is)
      
      -> one($os)->read(optional()) -> returns('a')
      -> one($os)->read(optional()) -> returns("\r")
      -> one($os)->read(optional()) -> returns('b')
      -> allowing($os)->read(optional()) -> returns(false)
      
      -> ignoring($os)
      );
    
    $encoder->encodeByteStream($os, $is);
    $this->assertEqual("a\r\nb", $collection->content);
  }
  
  public function testCanonicEncodeByteStreamGeneratesCorrectCrlf_2()
  {
    $encoder = $this->_getEncoder('7bit', true);
    
    $os = $this->_createOutputByteStream();
    $is = $this->_createInputByteStream();
    $collection = new Swift_StreamCollector();

    $this->_checking(Expectations::create()
      -> allowing($is)->write(any(), optional()) -> will($collection)
      -> ignoring($is)
      
      -> one($os)->read(optional()) -> returns('a')
      -> one($os)->read(optional()) -> returns("\n")
      -> one($os)->read(optional()) -> returns('b')
      -> allowing($os)->read(optional()) -> returns(false)
      
      -> ignoring($os)
      );
    
    $encoder->encodeByteStream($os, $is);
    $this->assertEqual("a\r\nb", $collection->content);
  }
  
  public function testCanonicEncodeByteStreamGeneratesCorrectCrlf_3()
  {
    $encoder = $this->_getEncoder('7bit', true);
    
    $os = $this->_createOutputByteStream();
    $is = $this->_createInputByteStream();
    $collection = new Swift_StreamCollector();

    $this->_checking(Expectations::create()
      -> allowing($is)->write(any(), optional()) -> will($collection)
      -> ignoring($is)
      
      -> one($os)->read(optional()) -> returns('a')
      -> one($os)->read(optional()) -> returns("\n\r")
      -> one($os)->read(optional()) -> returns('b')
      -> allowing($os)->read(optional()) -> returns(false)
      
      -> ignoring($os)
      );
    
    $encoder->encodeByteStream($os, $is);
    $this->assertEqual("a\r\n\r\nb", $collection->content);
  }
  
  public function testCanonicEncodeByteStreamGeneratesCorrectCrlf_4()
  {
    $encoder = $this->_getEncoder('7bit', true);
    
    $os = $this->_createOutputByteStream();
    $is = $this->_createInputByteStream();
    $collection = new Swift_StreamCollector();

    $this->_checking(Expectations::create()
      -> allowing($is)->write(any(), optional()) -> will($collection)
      -> ignoring($is)
      
      -> one($os)->read(optional()) -> returns('a')
      -> one($os)->read(optional()) -> returns("\n\n")
      -> one($os)->read(optional()) -> returns('b')
      -> allowing($os)->read(optional()) -> returns(false)
      
      -> ignoring($os)
      );
    
    $encoder->encodeByteStream($os, $is);
    $this->assertEqual("a\r\n\r\nb", $collection->content);
  }
  
  public function testCanonicEncodeByteStreamGeneratesCorrectCrlf_5()
  {
    $encoder = $this->_getEncoder('7bit', true);
    
    $os = $this->_createOutputByteStream();
    $is = $this->_createInputByteStream();
    $collection = new Swift_StreamCollector();

    $this->_checking(Expectations::create()
      -> allowing($is)->write(any(), optional()) -> will($collection)
      -> ignoring($is)
      
      -> one($os)->read(optional()) -> returns('a')
      -> one($os)->read(optional()) -> returns("\r\r")
      -> one($os)->read(optional()) -> returns('b')
      -> allowing($os)->read(optional()) -> returns(false)
      
      -> ignoring($os)
      );
    
    $encoder->encodeByteStream($os, $is);
    $this->assertEqual("a\r\n\r\nb", $collection->content);
  }
  
  // -- Private helpers
  
  private function _getEncoder($name, $canonical = false)
  {
    return new Swift_Mime_ContentEncoder_PlainContentEncoder($name, $canonical);
  }
  
  private function _createOutputByteStream($stub = false)
  {
    return $stub
      ? $this->_stub('Swift_OutputByteStream')
      : $this->_mock('Swift_OutputByteStream')
      ;
  }
  
  private function _createInputByteStream($stub = false)
  {
    return $stub
      ? $this->_stub('Swift_InputByteStream')
      : $this->_mock('Swift_InputByteStream')
      ;
  }
  
}