Archive/tests/file/block_file_test.php - zetacomponents - Git at Google

 <?php
 /**
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
  * @filesource
  * @package Archive
  * @version //autogen//
  * @subpackage Tests
  */

 /**
  * @package Archive
  * @version //autogen//
  * @subpackage Tests
  */
 class ezcArchiveBlockFileTest extends ezcTestCase
 {
     public function createTempFile( $file )
     {
         $original = dirname(__FILE__) . "/../data/$file";

         $tmpDir = $this->createTempDir( "ezcArchive_" );
         $tmpFile = $tmpDir . "/temp_file.tar";
         copy( $original, $tmpFile );

         return $tmpFile;
     }

     public function testOpenFile()
     {
         $blockFile = new ezcArchiveBlockFile( dirname(__FILE__) . "/../data/tar_ustar_2_textfiles.tar" );

         $data = $blockFile->current();
         $this->assertEquals( "file1.txt", substr( $data, 0, 9 ) );
     }

     public function testOpenNonExistingFile()
     {
         try
         {
             $blockFile = new ezcArchiveBlockFile( dirname(__FILE__) . "/../data/this_file_does_not_exist.tar" );
             $this->fail( "Expected a file not found exception." );
         }
         catch (ezcBaseFileNotFoundException $e)
         {
         }

         // Same test, but now with a gzipped compressed file.
         try
         {
             $blockFile = new ezcArchiveBlockFile( "compress.zlib://" . dirname( __FILE__ ) . "/../data/this_file_does_not_exist.tar.gz" );
             $this->fail( "Expected a file not found exception." );
         }
         catch ( ezcBaseFileNotFoundException $e )
         {
         }
     }

     public function testCompressedStream()
     {
         $dir = $this->createTempDir( "ezcArchive_" );
         // $file =   $dir . "/blockfile";
         $file =  "compress.zlib://" . $dir . "/blockfile";

         // Create the file.
         // Blocksize = 4.
         $bf = new ezcArchiveBlockFile( $file, true, 4 );
         $this->assertFalse ($bf->valid() );

         // Exact 1 block.
         $bf->append( "abcd" );
         $this->assertTrue ($bf->valid() );
         $this->assertEquals( 0, $bf->key(), "Current block should be 0" );
         $this->assertEquals( 0, $bf->getLastBlockNumber(), "Last block should be 0" );

         // halve block.
         $bf->append( "ef" );
         $this->assertEquals( 1, $bf->key(), "Current block should be 1" );
         $this->assertEquals( 1, $bf->getLastBlockNumber(), "Last block should be 1" );

         // File should contain: abcdef\0\0
         $this->assertEquals( "abcdef\0\0", file_get_contents( $file ) );

         $bf->rewind();
         $this->assertEquals( 0, $bf->key(), "Current block should be 0");
         $this->assertEquals( "abcd" , $bf->current() );
         $this->assertTrue( $bf->valid() );
         $this->assertEquals( 1 , $bf->getLastBlockNumber() );

         try
         {
             $bf->append( "ZZ" );
             $this->fail( "Expected an exception that the block could not be appended in the middle" );
         }
         catch ( ezcArchiveException $e ) { }

         $bf->next();
         $bf->append( "ZZ" );

         $this->assertEquals( 2, $bf->key(), "Current block should be 0" );
         $this->assertEquals( "ZZ" , $bf->current() );
         $this->assertTrue( $bf->valid() );
         $this->assertEquals( 2 , $bf->getLastBlockNumber() );
     }

     /*
     public function testGzipOpenFile()
     {
         $tmpDir = $this->createTempDir( "ezcArchive_" );
         $tmpFile = $tmpDir . "/compress.zlib://my_file.gz";

         // Create a new file, and set the blocksize to 5.
         $blockFile = new ezcArchiveBlockFile( $tmpFile, true, 5 );

         $this->removeTempDir();
     }
     */

     /*
     public function testOpenReadOnlyFile()
     {
         $original =  dirname(__FILE__) . "/../data/tar_ustar_2_textfiles.tar";

         $this->createTempDir( "ezcArchive_" );
         $tmpDir = $this->getTempDir();
         $readOnly = $tmpDir . "/read_only.tar";
         copy( $original, $readOnly );

         $blockFile = new ezcArchiveBlockFile( $readOnly );
         $data = $blockFile->current();
         $this->assertEquals( "file1.txt", substr($data, 0, 9), "Cannot read the copied file" );
         unset( $blockFile );

         chmod( $readOnly, 0400 );

         try
         {
             $blockFile = new ezcArchiveBlockFile( $readOnly );
             $data = $blockFile->current();
             $this->assertEquals( "file1.txt", substr($data, 0, 9), "Cannot read the copied READ-ONLY file" );
             unset( $blockFile );
         }
         catch ( ezcArchiveException $e )
         {
             $this->fail( "Exception: Cannot read the copied READ-ONLY file." );
         }

         chmod( $readOnly, 0777 );
         $this->removeTempDir();
     }

     public function testOpenFileAndCreateWhenNotExist()
     {
         $tmpDir = $this->createTempDir( "ezcArchive_" );
         $file = $tmpDir . "/file_does_not_exist.tar";

         $blockFile = new ezcArchiveBlockFile( $file, true );
         $this->assertFalse( $blockFile->current() );
         $this->assertTrue( $blockFile->isEmpty() );

         $blockFile->append( "Appended" );

         $this->assertFalse( $blockFile->isEmpty() );
         $data = $blockFile->current();
         $this->assertEquals( "Appended", substr( $data, 0, 8 ), "Failed to append to file." );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testForEaching()
     {
         $blockFile = new ezcArchiveBlockFile( dirname(__FILE__) . "/../data/tar_ustar_2_textfiles.tar" );

         $total = 0;
         foreach ( $blockFile as $blockNr => $data )
         {
             $total += $blockNr;
             $this->assertEquals( 512, strlen( $data ) );
         }

         $this->assertEquals( 190, $total, "Expected block numbers from 0 .. 19" );

         // And repeat the test.
         $total = 0;
         foreach ( $blockFile as $blockNr => $data )
         {
             $total += $blockNr;
             $this->assertEquals( 512, strlen( $data ) );
         }

         $this->assertEquals( 190, $total, "Expected block numbers from 0 .. 19" );
     }

     public function testTruncateAll()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $data = $blockFile->current();
         $this->assertEquals( "file1.txt", substr( $data, 0, 9 ), "Cannot read the tmp file" );

         $blockFile->truncate();
         $blockFile->rewind();
         $this->assertFalse( $blockFile->current(), "The current block element should be false." );
         $this->assertFalse( $blockFile->next(), "No forwarding should be allowed." );
         $this->assertFalse( $blockFile->valid(), "Current element should not be valid." );
         $this->assertFalse( $blockFile->key(), "No key available" );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testTruncatePart()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $blockFile->truncate(3);
         $blockFile->rewind();

         $data = $blockFile->current();
         $this->assertEquals( "file1.txt", substr( $data, 0, 9 ), "Cannot read the tmp file" );

         $blockFile->next(); // Block 2
         $this->assertTrue( $blockFile->valid() );

         $blockFile->next(); // Block 3
         $this->assertTrue( $blockFile->valid() );

         $blockFile->next(); // Should be false.
         $this->assertFalse( $blockFile->valid() );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function canWriteToReadOnlyFiles()
     {
         $dir = $this->getTempDir();
         touch( "$dir/asdfasdfasdfasdf" );
         chmod( "$dir/asdfasdfasdfasdf" , 0400 );

         $writable = is_writable( "$dir/asdfasdfasdfasdf" );

         unlink ( "$dir/asdfasdfasdfasdf" );
         return $writable;
     }

     public function testAppendReadOnlyException()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );

         chmod( $tmpFile, 0400 );

         try
         {
             $blockFile = new ezcArchiveBlockFile( $tmpFile );
             $data = $blockFile->current();
             $this->assertEquals( "file1.txt", substr( $data, 0, 9 ), "Cannot read the copied READ-ONLY file" );
         }
         catch ( ezcArchiveException $e )
         {
             $this->fail( "Exception: Cannot read the copied READ-ONLY file." );
         }

         try
         {
             // For normal users, this test should fail. However, root can still write.
             $blockFile->append( "This should fail" );

             if ( !$this->canWriteToReadOnlyFiles() )
             {
                 $this->fail( "Exception expected, since it is not possible to write to a read-only file." );
             }
         }
         catch ( ezcBaseFilePermissionException $e )
         {
         }

         chmod( $tmpFile, 0777 );
         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testAppendFirstBlock()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $blockFile->truncate();
         $blockFile->rewind();
         $blockFile->append( "Appended" );

         $this->assertTrue( $blockFile->valid(), "Current element should be valid." );

         // Point to the last block
         $data = $blockFile->current();
         $this->assertEquals( "Appended", substr( $data, 0, 8 ), "Failed to append to file." );

         $this->assertEquals( 0, $blockFile->key() );

         $this->assertFalse( $blockFile->next(), "Expected no more data" );
         $this->assertFalse( $blockFile->valid(), "Not valid anymore" );
         $this->assertFalse( $blockFile->current(), "No value expected" );
         $this->assertFalse( $blockFile->key(), "No key should be available" );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testAppendAfterFirstBlock()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         // Test the current file.
         $total = 0;
         foreach ( $blockFile as $blockNr => $data )
         {
             $total += $blockNr;
             $this->assertEquals( 512, strlen( $data ) );
         }

         $this->assertEquals( 190, $total, "Expected block numbers from 0 .. 19" );

         // Append after the first block.
         $blockFile->rewind();

         // First block?
         $data = $blockFile->current();
         $this->assertEquals( "file1.txt", substr( $data, 0, 9 ), "First block is wrong." );

         $blockFile->append( "My appended text" );

         $data = $blockFile->current();
         $this->assertEquals( "My appended text", substr( $data, 0, 16 ), "Appended block is wrong." );

         // Test the complete block now.
         $blockFile->rewind();

         $total = 0;
         foreach ( $blockFile as $blockNr => $data )
         {
             $total += $blockNr;
             $this->assertEquals( 512, strlen( $data ) );
         }

         $this->assertEquals( 1, $total, "Expected block numbers 0 and 1" );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testAppendAtEndOfFile()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         while ( $blockFile->next() );

         // Not valid anymore.
         $blockFile->append( "My appended text" );

         $data = $blockFile->current();
         $this->assertEquals( "My appended text", substr( $data, 0, 16 ), "Appended block is wrong." );

         // Test the complete block now.
         $blockFile->rewind();

         $total = 0;
         foreach ( $blockFile as $blockNr => $data )
         {
             $total += $blockNr;
             $this->assertEquals( 512, strlen( $data ) );
         }

         $this->assertEquals( 210, $total, "Expected block numbers 0 .. 20" );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testAppendMultipleBlocks()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $blockFile->truncate();
         $blockFile->rewind();
         $blockFile->append( "Hello" );
         $blockFile->append( "World" );
         $blockFile->append( "This is the third block." );

         $blockFile->rewind();
         $total = 0;
         foreach ( $blockFile as $blockNr => $data )
         {
             $total += $blockNr;
             $this->assertEquals( 512, strlen( $data ) );
         }

         $this->assertEquals( 3, $total, "Expected block numbers 0 .. 2" );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testNullBlock()
     {
         $blockFile = new ezcArchiveBlockFile( dirname(__FILE__) . "/../data/tar_ustar_2_textfiles.tar" );

         $this->assertFalse( $blockFile->isNullBlock(), "First block shouldn't be a null block." );
         $blockFile->next();
         $blockFile->next();
         $blockFile->next();
         $this->assertFalse( $blockFile->isNullBlock(), "Forth block shouldn't be a null block." );

         $blockFile->next();
         $this->assertTrue( $blockFile->isNullBlock(), "Expected a null block." );

         $blockFile->next();
         $this->assertTrue( $blockFile->isNullBlock(), "Expected a null block." );

         // Go to the end of the file.
         while ( $blockFile->next() );

         $this->assertFalse( $blockFile->valid(), "End of archive should be reached." );
         $this->assertFalse( $blockFile->isNullBlock(), "This shouldn't be a nullblock" );
     }

     public function testAppendNullBlock()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $blockFile->truncate();
         $blockFile->rewind();
         $blockFile->appendNullBlock();

         $this->assertTrue( $blockFile->valid(), "Should be a null block here." );
         $this->assertTrue( $blockFile->isNullBlock(), "Should be a null block here." );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testIsEmpty()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $this->assertFalse( $blockFile->isEmpty() );
         $blockFile->append( "Blaap" );
         $this->assertFalse( $blockFile->isEmpty() );

         $blockFile->truncate(1);
         $this->assertFalse( $blockFile->isEmpty() );
         $blockFile->append( "Blaap" );
         $this->assertFalse( $blockFile->isEmpty() );

         $blockFile->truncate();
         $this->assertTrue( $blockFile->isEmpty() );

         $blockFile->rewind();
         $blockFile->append( "blaap" );
         $this->assertFalse( $blockFile->isEmpty() );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testBlockFromBytes()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $this->assertEquals( 2, $blockFile->getBlocksFromBytes( 666 ) );
         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testSeekPositions()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $blockFile->seek( 2 ); // Search the third block
         $data = $blockFile->current();
         $this->assertEquals( "file2.txt", substr( $data, 0, 9 ) );
         $this->assertEquals( 2, $blockFile->key() );

         $blockFile->seek( 0 ); // Search the first block
         $data = $blockFile->current();
         $this->assertEquals( "file1.txt", substr( $data, 0, 9 ) );
         $this->assertEquals( 0, $blockFile->key() );

         $blockFile->seek( 19 ); // Search the last block
         $this->assertTrue( $blockFile->isNullBlock() );
         $this->assertFalse( $blockFile->next(), "Expected to be at the last block." );

         $blockFile->seek( -1 ); // Invalid block search.
         $this->assertFalse( $blockFile->valid() );
         $this->assertFalse( $blockFile->current() );
         $this->assertFalse( $blockFile->key() );
         $this->assertFalse( $blockFile->next(), "Should all be false" );
         $this->assertFalse( $blockFile->next(), "Should all be false" );
         $this->assertFalse( $blockFile->next(), "Should all be false" );

         // Should be valid again.
         $blockFile->seek( 2 ); // Search the third block
         $data = $blockFile->current();
         $this->assertEquals( "file2.txt", substr( $data, 0, 9 ) );
         $this->assertEquals( 2, $blockFile->key() );

         $blockFile->seek( 20 ); // Invalid block search.
         $this->assertFalse( $blockFile->valid() );
         $this->assertFalse( $blockFile->current() );
         $this->assertFalse( $blockFile->key() );
         $this->assertFalse( $blockFile->next() );
         $this->assertFalse( $blockFile->next() );
         $this->assertFalse( $blockFile->next() );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testSeekEndOfFile()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $blockFile->seek( 0, SEEK_END ); // Search the last block
         $this->assertEquals( 19, $blockFile->key(), "Expected to be at the last block." );

         $this->assertTrue( $blockFile->valid(), "Last block should be valid" );
         $this->assertFalse( $blockFile->next(), "Cannot move past the last block." );
         $this->assertFalse( $blockFile->valid() );

         $blockFile->seek( -2, SEEK_END ); // Search the last block
         $this->assertEquals( 17, $blockFile->key(), "Expected to be at the 18th block." );

         $blockFile->next();
         $this->assertTrue( $blockFile->valid(), "Expected to be at the 19th block." );
         $blockFile->next();
         $this->assertTrue( $blockFile->valid(), "Expected to be at the 20th block." );
         $this->assertFalse( $blockFile->next(), "Expected to be at the end." );

         // File with no blocks.
         $blockFile->truncate();
         $blockFile->seek( 0, SEEK_END ); // Search the last block
         $this->assertFalse( $blockFile->valid(), "No block should be here." );

         // File with one block.
         $blockFile->append( "My block" );
         $blockFile->seek(0, SEEK_END ); // Should be the first and last block.

         $data = $blockFile->current();
         $this->assertEquals( "My block", substr( $data, 0, 8 ) );
         $this->assertTrue( $blockFile->valid() );

         // First block.
         $blockFile->seek( 0 );
         $data = $blockFile->current();
         $this->assertEquals( "My block", substr( $data, 0, 8 ) );
         $this->assertTrue( $blockFile->valid() );

         // Invalid block.
         $blockFile->seek( -1, SEEK_END ); // Should be the first and last block.

         $this->assertFalse( $blockFile->current() );
         $this->assertFalse( $blockFile->valid() );

         unset( $blockFile );
         $this->removeTempDir();
     }

     public function testSeekCurrentLocation()
     {
         $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
         $blockFile = new ezcArchiveBlockFile( $tmpFile );

         $blockFile->next(); // Block number: 1.
         $this->assertEquals( 1, $blockFile->key() );

         $blockFile->seek( 0, SEEK_CUR ); // Stay at the same block
         $this->assertEquals( 1, $blockFile->key() );

         $blockFile->seek( 1, SEEK_CUR ); // one block further
         $this->assertEquals( 2, $blockFile->key() );

         $data = $blockFile->current();
         $this->assertEquals( "file2.txt", substr( $data, 0, 9 ) );

         $blockFile->seek( -2, SEEK_CUR ); // two blocks back.
         $this->assertEquals( 0, $blockFile->key() );

         $data = $blockFile->current();
         $this->assertEquals( "file1.txt", substr( $data, 0, 9 ) );

         unset( $blockFile );
         $this->removeTempDir();
     }
     */

 //    public function testLastBlockNumber()
 //    {
 //        $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
 //        $blockFile = new ezcArchiveBlockFile( $tmpFile );
 //
 //        $this->assertEquals( -1, $blockFile->getLastBlockNumber(), "Last blocknumber supposed to be unknown" );
 //
 //        while ( $blockFile->next() );
 //
 //        $this->assertEquals( 19, $blockFile->getLastBlockNumber(), "Last blocknumber supposed to be 19. (0 .. 19)" );
 //
 //        $blockFile->append( "Hello" );
 //        $this->assertEquals( 20, $blockFile->getLastBlockNumber() );
 //
 //        $blockFile->append( "Hello" );
 //        $this->assertEquals( 21, $blockFile->getLastBlockNumber() );
 //
 //        $blockFile->truncate();
 //        $blockFile->rewind();
 //        $this->assertEquals( -1, $blockFile->getLastBlockNumber() );
 //
 //        // First block
 //        $blockFile->append( "Hello" );
 //        $this->assertEquals( 0, $blockFile->getLastBlockNumber() );
 //        $this->assertEquals( 0, $blockFile->key() );
 //
 //        $blockFile->append( "Hello" );
 //        $this->assertEquals( 1, $blockFile->getLastBlockNumber() );
 //        $this->assertEquals( 1, $blockFile->key() );
 //
 //        $blockFile->rewind();
 //
 //        // First block
 //        $blockFile->append("Hello");
 //        $this->assertEquals( 1, $blockFile->getLastBlockNumber() );
 //
 //        /*
 //        $blockFile->next(); // Block number: 1.
 //        $this->assertEquals( 1, $blockFile->key() );
 //
 //        $blockFile->seek( 0, SEEK_CUR ); // Stay at the same block
 //        $this->assertEquals( 1, $blockFile->key() );
 //
 //        $blockFile->seek( 1, SEEK_CUR ); // one block further
 //        $this->assertEquals( 2, $blockFile->key() );
 //
 //        $data = $blockFile->current();
 //        $this->assertEquals( "file2.txt", substr( $data, 0, 9 ) );
 //
 //        $blockFile->seek( -2, SEEK_CUR ); // two blocks back.
 //        $this->assertEquals( 0, $blockFile->key() );
 //
 //        $data = $blockFile->current();
 //        $this->assertEquals( "file1.txt", substr( $data, 0, 9 ) );
 //
 //        unset( $blockFile );
 //         */
 //        $this->removeTempDir();
 //    }

     public static function suite()
     {
         return new PHPUnit_Framework_TestSuite( __CLASS__ );
     }
 }
 ?>
	<?php
	/**
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
	* @filesource
	* @package Archive
	* @version //autogen//
	* @subpackage Tests
	*/

	/**
	* @package Archive
	* @version //autogen//
	* @subpackage Tests
	*/
	class ezcArchiveBlockFileTest extends ezcTestCase
	{
	public function createTempFile( $file )
	{
	$original = dirname(__FILE__) . "/../data/$file";

	$tmpDir = $this->createTempDir( "ezcArchive_" );
	$tmpFile = $tmpDir . "/temp_file.tar";
	copy( $original, $tmpFile );

	return $tmpFile;
	}

	public function testOpenFile()
	{
	$blockFile = new ezcArchiveBlockFile( dirname(__FILE__) . "/../data/tar_ustar_2_textfiles.tar" );

	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr( $data, 0, 9 ) );
	}

	public function testOpenNonExistingFile()
	{
	try
	{
	$blockFile = new ezcArchiveBlockFile( dirname(__FILE__) . "/../data/this_file_does_not_exist.tar" );
	$this->fail( "Expected a file not found exception." );
	}
	catch (ezcBaseFileNotFoundException $e)
	{
	}

	// Same test, but now with a gzipped compressed file.
	try
	{
	$blockFile = new ezcArchiveBlockFile( "compress.zlib://" . dirname( __FILE__ ) . "/../data/this_file_does_not_exist.tar.gz" );
	$this->fail( "Expected a file not found exception." );
	}
	catch ( ezcBaseFileNotFoundException $e )
	{
	}
	}

	public function testCompressedStream()
	{
	$dir = $this->createTempDir( "ezcArchive_" );
	// $file = $dir . "/blockfile";
	$file = "compress.zlib://" . $dir . "/blockfile";

	// Create the file.
	// Blocksize = 4.
	$bf = new ezcArchiveBlockFile( $file, true, 4 );
	$this->assertFalse ($bf->valid() );

	// Exact 1 block.
	$bf->append( "abcd" );
	$this->assertTrue ($bf->valid() );
	$this->assertEquals( 0, $bf->key(), "Current block should be 0" );
	$this->assertEquals( 0, $bf->getLastBlockNumber(), "Last block should be 0" );

	// halve block.
	$bf->append( "ef" );
	$this->assertEquals( 1, $bf->key(), "Current block should be 1" );
	$this->assertEquals( 1, $bf->getLastBlockNumber(), "Last block should be 1" );

	// File should contain: abcdef\0\0
	$this->assertEquals( "abcdef\0\0", file_get_contents( $file ) );

	$bf->rewind();
	$this->assertEquals( 0, $bf->key(), "Current block should be 0");
	$this->assertEquals( "abcd" , $bf->current() );
	$this->assertTrue( $bf->valid() );
	$this->assertEquals( 1 , $bf->getLastBlockNumber() );

	try
	{
	$bf->append( "ZZ" );
	$this->fail( "Expected an exception that the block could not be appended in the middle" );
	}
	catch ( ezcArchiveException $e ) { }

	$bf->next();
	$bf->append( "ZZ" );

	$this->assertEquals( 2, $bf->key(), "Current block should be 0" );
	$this->assertEquals( "ZZ" , $bf->current() );
	$this->assertTrue( $bf->valid() );
	$this->assertEquals( 2 , $bf->getLastBlockNumber() );
	}

	/*
	public function testGzipOpenFile()
	{
	$tmpDir = $this->createTempDir( "ezcArchive_" );
	$tmpFile = $tmpDir . "/compress.zlib://my_file.gz";

	// Create a new file, and set the blocksize to 5.
	$blockFile = new ezcArchiveBlockFile( $tmpFile, true, 5 );

	$this->removeTempDir();
	}
	*/

	/*
	public function testOpenReadOnlyFile()
	{
	$original = dirname(__FILE__) . "/../data/tar_ustar_2_textfiles.tar";

	$this->createTempDir( "ezcArchive_" );
	$tmpDir = $this->getTempDir();
	$readOnly = $tmpDir . "/read_only.tar";
	copy( $original, $readOnly );

	$blockFile = new ezcArchiveBlockFile( $readOnly );
	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr($data, 0, 9), "Cannot read the copied file" );
	unset( $blockFile );

	chmod( $readOnly, 0400 );

	try
	{
	$blockFile = new ezcArchiveBlockFile( $readOnly );
	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr($data, 0, 9), "Cannot read the copied READ-ONLY file" );
	unset( $blockFile );
	}
	catch ( ezcArchiveException $e )
	{
	$this->fail( "Exception: Cannot read the copied READ-ONLY file." );
	}

	chmod( $readOnly, 0777 );
	$this->removeTempDir();
	}

	public function testOpenFileAndCreateWhenNotExist()
	{
	$tmpDir = $this->createTempDir( "ezcArchive_" );
	$file = $tmpDir . "/file_does_not_exist.tar";

	$blockFile = new ezcArchiveBlockFile( $file, true );
	$this->assertFalse( $blockFile->current() );
	$this->assertTrue( $blockFile->isEmpty() );

	$blockFile->append( "Appended" );

	$this->assertFalse( $blockFile->isEmpty() );
	$data = $blockFile->current();
	$this->assertEquals( "Appended", substr( $data, 0, 8 ), "Failed to append to file." );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testForEaching()
	{
	$blockFile = new ezcArchiveBlockFile( dirname(__FILE__) . "/../data/tar_ustar_2_textfiles.tar" );

	$total = 0;
	foreach ( $blockFile as $blockNr => $data )
	{
	$total += $blockNr;
	$this->assertEquals( 512, strlen( $data ) );
	}

	$this->assertEquals( 190, $total, "Expected block numbers from 0 .. 19" );

	// And repeat the test.
	$total = 0;
	foreach ( $blockFile as $blockNr => $data )
	{
	$total += $blockNr;
	$this->assertEquals( 512, strlen( $data ) );
	}

	$this->assertEquals( 190, $total, "Expected block numbers from 0 .. 19" );
	}

	public function testTruncateAll()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr( $data, 0, 9 ), "Cannot read the tmp file" );

	$blockFile->truncate();
	$blockFile->rewind();
	$this->assertFalse( $blockFile->current(), "The current block element should be false." );
	$this->assertFalse( $blockFile->next(), "No forwarding should be allowed." );
	$this->assertFalse( $blockFile->valid(), "Current element should not be valid." );
	$this->assertFalse( $blockFile->key(), "No key available" );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testTruncatePart()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$blockFile->truncate(3);
	$blockFile->rewind();

	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr( $data, 0, 9 ), "Cannot read the tmp file" );

	$blockFile->next(); // Block 2
	$this->assertTrue( $blockFile->valid() );

	$blockFile->next(); // Block 3
	$this->assertTrue( $blockFile->valid() );

	$blockFile->next(); // Should be false.
	$this->assertFalse( $blockFile->valid() );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function canWriteToReadOnlyFiles()
	{
	$dir = $this->getTempDir();
	touch( "$dir/asdfasdfasdfasdf" );
	chmod( "$dir/asdfasdfasdfasdf" , 0400 );

	$writable = is_writable( "$dir/asdfasdfasdfasdf" );

	unlink ( "$dir/asdfasdfasdfasdf" );
	return $writable;
	}

	public function testAppendReadOnlyException()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );

	chmod( $tmpFile, 0400 );

	try
	{
	$blockFile = new ezcArchiveBlockFile( $tmpFile );
	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr( $data, 0, 9 ), "Cannot read the copied READ-ONLY file" );
	}
	catch ( ezcArchiveException $e )
	{
	$this->fail( "Exception: Cannot read the copied READ-ONLY file." );
	}

	try
	{
	// For normal users, this test should fail. However, root can still write.
	$blockFile->append( "This should fail" );

	if ( !$this->canWriteToReadOnlyFiles() )
	{
	$this->fail( "Exception expected, since it is not possible to write to a read-only file." );
	}
	}
	catch ( ezcBaseFilePermissionException $e )
	{
	}

	chmod( $tmpFile, 0777 );
	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testAppendFirstBlock()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$blockFile->truncate();
	$blockFile->rewind();
	$blockFile->append( "Appended" );

	$this->assertTrue( $blockFile->valid(), "Current element should be valid." );

	// Point to the last block
	$data = $blockFile->current();
	$this->assertEquals( "Appended", substr( $data, 0, 8 ), "Failed to append to file." );

	$this->assertEquals( 0, $blockFile->key() );

	$this->assertFalse( $blockFile->next(), "Expected no more data" );
	$this->assertFalse( $blockFile->valid(), "Not valid anymore" );
	$this->assertFalse( $blockFile->current(), "No value expected" );
	$this->assertFalse( $blockFile->key(), "No key should be available" );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testAppendAfterFirstBlock()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	// Test the current file.
	$total = 0;
	foreach ( $blockFile as $blockNr => $data )
	{
	$total += $blockNr;
	$this->assertEquals( 512, strlen( $data ) );
	}

	$this->assertEquals( 190, $total, "Expected block numbers from 0 .. 19" );

	// Append after the first block.
	$blockFile->rewind();

	// First block?
	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr( $data, 0, 9 ), "First block is wrong." );

	$blockFile->append( "My appended text" );

	$data = $blockFile->current();
	$this->assertEquals( "My appended text", substr( $data, 0, 16 ), "Appended block is wrong." );

	// Test the complete block now.
	$blockFile->rewind();

	$total = 0;
	foreach ( $blockFile as $blockNr => $data )
	{
	$total += $blockNr;
	$this->assertEquals( 512, strlen( $data ) );
	}

	$this->assertEquals( 1, $total, "Expected block numbers 0 and 1" );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testAppendAtEndOfFile()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	while ( $blockFile->next() );

	// Not valid anymore.
	$blockFile->append( "My appended text" );

	$data = $blockFile->current();
	$this->assertEquals( "My appended text", substr( $data, 0, 16 ), "Appended block is wrong." );

	// Test the complete block now.
	$blockFile->rewind();

	$total = 0;
	foreach ( $blockFile as $blockNr => $data )
	{
	$total += $blockNr;
	$this->assertEquals( 512, strlen( $data ) );
	}

	$this->assertEquals( 210, $total, "Expected block numbers 0 .. 20" );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testAppendMultipleBlocks()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$blockFile->truncate();
	$blockFile->rewind();
	$blockFile->append( "Hello" );
	$blockFile->append( "World" );
	$blockFile->append( "This is the third block." );

	$blockFile->rewind();
	$total = 0;
	foreach ( $blockFile as $blockNr => $data )
	{
	$total += $blockNr;
	$this->assertEquals( 512, strlen( $data ) );
	}

	$this->assertEquals( 3, $total, "Expected block numbers 0 .. 2" );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testNullBlock()
	{
	$blockFile = new ezcArchiveBlockFile( dirname(__FILE__) . "/../data/tar_ustar_2_textfiles.tar" );

	$this->assertFalse( $blockFile->isNullBlock(), "First block shouldn't be a null block." );
	$blockFile->next();
	$blockFile->next();
	$blockFile->next();
	$this->assertFalse( $blockFile->isNullBlock(), "Forth block shouldn't be a null block." );

	$blockFile->next();
	$this->assertTrue( $blockFile->isNullBlock(), "Expected a null block." );

	$blockFile->next();
	$this->assertTrue( $blockFile->isNullBlock(), "Expected a null block." );

	// Go to the end of the file.
	while ( $blockFile->next() );

	$this->assertFalse( $blockFile->valid(), "End of archive should be reached." );
	$this->assertFalse( $blockFile->isNullBlock(), "This shouldn't be a nullblock" );
	}

	public function testAppendNullBlock()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$blockFile->truncate();
	$blockFile->rewind();
	$blockFile->appendNullBlock();

	$this->assertTrue( $blockFile->valid(), "Should be a null block here." );
	$this->assertTrue( $blockFile->isNullBlock(), "Should be a null block here." );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testIsEmpty()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$this->assertFalse( $blockFile->isEmpty() );
	$blockFile->append( "Blaap" );
	$this->assertFalse( $blockFile->isEmpty() );

	$blockFile->truncate(1);
	$this->assertFalse( $blockFile->isEmpty() );
	$blockFile->append( "Blaap" );
	$this->assertFalse( $blockFile->isEmpty() );

	$blockFile->truncate();
	$this->assertTrue( $blockFile->isEmpty() );

	$blockFile->rewind();
	$blockFile->append( "blaap" );
	$this->assertFalse( $blockFile->isEmpty() );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testBlockFromBytes()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$this->assertEquals( 2, $blockFile->getBlocksFromBytes( 666 ) );
	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testSeekPositions()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$blockFile->seek( 2 ); // Search the third block
	$data = $blockFile->current();
	$this->assertEquals( "file2.txt", substr( $data, 0, 9 ) );
	$this->assertEquals( 2, $blockFile->key() );

	$blockFile->seek( 0 ); // Search the first block
	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr( $data, 0, 9 ) );
	$this->assertEquals( 0, $blockFile->key() );

	$blockFile->seek( 19 ); // Search the last block
	$this->assertTrue( $blockFile->isNullBlock() );
	$this->assertFalse( $blockFile->next(), "Expected to be at the last block." );

	$blockFile->seek( -1 ); // Invalid block search.
	$this->assertFalse( $blockFile->valid() );
	$this->assertFalse( $blockFile->current() );
	$this->assertFalse( $blockFile->key() );
	$this->assertFalse( $blockFile->next(), "Should all be false" );
	$this->assertFalse( $blockFile->next(), "Should all be false" );
	$this->assertFalse( $blockFile->next(), "Should all be false" );

	// Should be valid again.
	$blockFile->seek( 2 ); // Search the third block
	$data = $blockFile->current();
	$this->assertEquals( "file2.txt", substr( $data, 0, 9 ) );
	$this->assertEquals( 2, $blockFile->key() );

	$blockFile->seek( 20 ); // Invalid block search.
	$this->assertFalse( $blockFile->valid() );
	$this->assertFalse( $blockFile->current() );
	$this->assertFalse( $blockFile->key() );
	$this->assertFalse( $blockFile->next() );
	$this->assertFalse( $blockFile->next() );
	$this->assertFalse( $blockFile->next() );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testSeekEndOfFile()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$blockFile->seek( 0, SEEK_END ); // Search the last block
	$this->assertEquals( 19, $blockFile->key(), "Expected to be at the last block." );

	$this->assertTrue( $blockFile->valid(), "Last block should be valid" );
	$this->assertFalse( $blockFile->next(), "Cannot move past the last block." );
	$this->assertFalse( $blockFile->valid() );

	$blockFile->seek( -2, SEEK_END ); // Search the last block
	$this->assertEquals( 17, $blockFile->key(), "Expected to be at the 18th block." );

	$blockFile->next();
	$this->assertTrue( $blockFile->valid(), "Expected to be at the 19th block." );
	$blockFile->next();
	$this->assertTrue( $blockFile->valid(), "Expected to be at the 20th block." );
	$this->assertFalse( $blockFile->next(), "Expected to be at the end." );

	// File with no blocks.
	$blockFile->truncate();
	$blockFile->seek( 0, SEEK_END ); // Search the last block
	$this->assertFalse( $blockFile->valid(), "No block should be here." );

	// File with one block.
	$blockFile->append( "My block" );
	$blockFile->seek(0, SEEK_END ); // Should be the first and last block.

	$data = $blockFile->current();
	$this->assertEquals( "My block", substr( $data, 0, 8 ) );
	$this->assertTrue( $blockFile->valid() );

	// First block.
	$blockFile->seek( 0 );
	$data = $blockFile->current();
	$this->assertEquals( "My block", substr( $data, 0, 8 ) );
	$this->assertTrue( $blockFile->valid() );

	// Invalid block.
	$blockFile->seek( -1, SEEK_END ); // Should be the first and last block.

	$this->assertFalse( $blockFile->current() );
	$this->assertFalse( $blockFile->valid() );

	unset( $blockFile );
	$this->removeTempDir();
	}

	public function testSeekCurrentLocation()
	{
	$tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	$blockFile = new ezcArchiveBlockFile( $tmpFile );

	$blockFile->next(); // Block number: 1.
	$this->assertEquals( 1, $blockFile->key() );

	$blockFile->seek( 0, SEEK_CUR ); // Stay at the same block
	$this->assertEquals( 1, $blockFile->key() );

	$blockFile->seek( 1, SEEK_CUR ); // one block further
	$this->assertEquals( 2, $blockFile->key() );

	$data = $blockFile->current();
	$this->assertEquals( "file2.txt", substr( $data, 0, 9 ) );

	$blockFile->seek( -2, SEEK_CUR ); // two blocks back.
	$this->assertEquals( 0, $blockFile->key() );

	$data = $blockFile->current();
	$this->assertEquals( "file1.txt", substr( $data, 0, 9 ) );

	unset( $blockFile );
	$this->removeTempDir();
	}
	*/

	// public function testLastBlockNumber()
	// {
	// $tmpFile = $this->createTempFile( "tar_ustar_2_textfiles.tar" );
	// $blockFile = new ezcArchiveBlockFile( $tmpFile );
	//
	// $this->assertEquals( -1, $blockFile->getLastBlockNumber(), "Last blocknumber supposed to be unknown" );
	//
	// while ( $blockFile->next() );
	//
	// $this->assertEquals( 19, $blockFile->getLastBlockNumber(), "Last blocknumber supposed to be 19. (0 .. 19)" );
	//
	// $blockFile->append( "Hello" );
	// $this->assertEquals( 20, $blockFile->getLastBlockNumber() );
	//
	// $blockFile->append( "Hello" );
	// $this->assertEquals( 21, $blockFile->getLastBlockNumber() );
	//
	// $blockFile->truncate();
	// $blockFile->rewind();
	// $this->assertEquals( -1, $blockFile->getLastBlockNumber() );
	//
	// // First block
	// $blockFile->append( "Hello" );
	// $this->assertEquals( 0, $blockFile->getLastBlockNumber() );
	// $this->assertEquals( 0, $blockFile->key() );
	//
	// $blockFile->append( "Hello" );
	// $this->assertEquals( 1, $blockFile->getLastBlockNumber() );
	// $this->assertEquals( 1, $blockFile->key() );
	//
	// $blockFile->rewind();
	//
	// // First block
	// $blockFile->append("Hello");
	// $this->assertEquals( 1, $blockFile->getLastBlockNumber() );
	//
	// /*
	// $blockFile->next(); // Block number: 1.
	// $this->assertEquals( 1, $blockFile->key() );
	//
	// $blockFile->seek( 0, SEEK_CUR ); // Stay at the same block
	// $this->assertEquals( 1, $blockFile->key() );
	//
	// $blockFile->seek( 1, SEEK_CUR ); // one block further
	// $this->assertEquals( 2, $blockFile->key() );
	//
	// $data = $blockFile->current();
	// $this->assertEquals( "file2.txt", substr( $data, 0, 9 ) );
	//
	// $blockFile->seek( -2, SEEK_CUR ); // two blocks back.
	// $this->assertEquals( 0, $blockFile->key() );
	//
	// $data = $blockFile->current();
	// $this->assertEquals( "file1.txt", substr( $data, 0, 9 ) );
	//
	// unset( $blockFile );
	// */
	// $this->removeTempDir();
	// }

	public static function suite()
	{
	return new PHPUnit_Framework_TestSuite( __CLASS__ );
	}
	}
	?>