ConsoleTools/tests/table_row_test.php - zetacomponents - Git at Google

 <?php
 /**
  * ezcConsoleTableRowTest class.
  *
  * 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.
  *
  * @package ConsoleTools
  * @subpackage Tests
  * @version //autogentag//
  * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
  */

 /**
  * Test suite for ezcConsoleTableRow class.
  *
  * @package ConsoleTools
  * @subpackage Tests
  */
 class ezcConsoleTableRowTest extends ezcTestCase
 {
 	public static function suite()
 	{
 		return new PHPUnit_Framework_TestSuite( "ezcConsoleTableRowTest" );
 	}

     public function testCtorSuccess_1()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell() );
         $this->assertEquals(
             2,
             count( $row ),
             "ezcConsoleTableRow not correctly created."
         );
     }

     public function testCtorSuccess_2()
     {
         $row = new ezcConsoleTableRow();
         $this->assertEquals(
             0,
             count( $row ),
             "ezcConsoleTableRow not correctly created."
         );
     }

     public function testCtorFailure()
     {
         $exceptionThrown = false;
         try
         {
             $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), 'foo' );
         }
         catch ( ezcBaseValueException $e )
         {
             $exceptionThrown = true;
         }
         $this->assertTrue( $exceptionThrown, "Exception not thrown on invald constructor parameter." );
     }

     public function testAppend()
     {
         $row = new ezcConsoleTableRow();
         $row[]->content = 'foo';
         $this->assertTrue(
             $row[0] instanceof ezcConsoleTableCell,
             "ezcConsoleTableCell not correctly created on write access."
         );
     }

     public function testOntheflyCreationRead_1()
     {
         $row = new ezcConsoleTableRow();
         $this->assertTrue(
             $row[0] instanceof ezcConsoleTableCell,
             "ezcConsoleTableCell not correctly created on write access."
         );
     }

     public function testOntheflyCreationRead_2()
     {
         $row = new ezcConsoleTableRow();
         $row[0]; $row[1]; $row[2];
         $this->assertTrue(
             count( $row ) == 3,
             "ezcConsoleTableCell not correctly created on write access."
         );
     }

     public function testOntheflyCreationRead_3()
     {
         $row = new ezcConsoleTableRow();
         $row[0]->content = 'test';
         $row[1]->format = 'test';
         $row[2]->align = ezcConsoleTable::ALIGN_CENTER;
         $this->assertTrue(
             count($row) == 3,
             "ezcConsoleTableCell not correctly created on write access."
         );
     }

     public function testOntheflyCreationWrite_1()
     {
         $row = new ezcConsoleTableRow();
         $row[0] = new ezcConsoleTableCell();
         $row[0]->content = 'test';
         $this->assertTrue(
             count($row) == 1 && $row[0] instanceof ezcConsoleTableCell && $row[0]->content === 'test',
             "ezcConsoleTableCell not correctly created on write access."
         );
     }

     public function testNoOntheflyCreationIsset()
     {
         $row = new ezcConsoleTableRow();
         $this->assertEquals(
             isset( $row[0] ),
             false,
             "ezcConsoleTableCell created on isset access."
         );
         $this->assertEquals(
             count($row),
             0,
             "ezcConsoleTableCell created on isset access."
         );
     }

     public function testForeach_1()
     {
         $row = new ezcConsoleTableRow();
         for ( $i = 0; $i < 10; $i++ )
         {
             $row[$i]->content = 'Is '.$i;
         }
         $this->assertEquals(
             count( $row ),
             10,
             "ezcConsoleTableCells not correctly created on write access."
         );
         foreach ( $row as $id => $cell )
         {
             $this->assertEquals(
                 'Is ' . $id,
                 $cell->content,
                 "Cell with wrong content found on iteration."
             );
         }
     }

     public function testForeach_2()
     {
         $row = new ezcConsoleTableRow();
         for ( $i = 0; $i < 20; $i += 2 )
         {
             $row[$i]->content = 'Is '.$i;
         }
         $this->assertEquals(
             count( $row ),
             19,
             "ezcConsoleTableCells."
         );
         foreach ( $row as $id => $cell );
         {
             $this->assertEquals(
                 'Is ' . $id,
                 $cell->content,
                 "Cell with wrong content found on iteration."
             );
         }
     }

     public function testCount_1()
     {
         $row = new ezcConsoleTableRow();
         $row[0]->content = "0";
         $this->assertEquals(
             1,
             count( $row ),
             "Did not count number of cells correctly"
         );
     }

     public function testCount_2()
     {
         $row = new ezcConsoleTableRow();
         $row[1]->content = "0";
         $this->assertEquals(
             2,
             count( $row ),
             "Did not count number of cells correctly"
         );
     }

     public function testCount_3()
     {
         $row = new ezcConsoleTableRow();
         $row[10]->content = "0";
         $this->assertEquals(
             11,
             count( $row ),
             "Did not count number of cells correctly"
         );
     }

     public function testNotSetAllCellsProperties_1()
     {
         $row = new ezcConsoleTableRow();
         for ( $i = 0; $i < 10; $i++ )
         {
             $row[$i]->content = (string) $i;
         }

         $row->align = ezcConsoleTable::ALIGN_CENTER;

         foreach ( $row as $cell )
         {
             $this->assertEquals(
                 ezcConsoleTable::ALIGN_DEFAULT,
                 $cell->align,
                 "Did not set alignment correctly for all contained cells."
             );
         }
     }

     public function testNotSetAllCellsProperties_2()
     {
         $row = new ezcConsoleTableRow();
         for ( $i = 0; $i < 10; $i++ )
         {
             $row[$i]->content = (string) $i;
         }

         $row->format = 'headline';

         foreach ( $row as $cell )
         {
             $this->assertEquals(
                 'default',
                 $cell->format,
                 "Did not set alignment correctly for all contained cells."
             );
         }
     }

     public function testGetAccessSuccess()
     {
         $row = new ezcConsoleTableRow();
         $this->assertEquals( "default", $row->borderFormat );
         $this->assertEquals( "default", $row->format );
         $this->assertEquals( ezcConsoleTable::ALIGN_DEFAULT, $row->align );
     }

     public function testGetAccessFailure()
     {
         $row = new ezcConsoleTableRow();
         try
         {
             echo $row->foo;
         }
         catch ( ezcBasePropertyNotFoundException $e )
         {
             return;
         }
         $this->fail( "Exception not thrown on get access of invalid property foo." );
     }

     public function testSetAccessSuccess()
     {
         $row = new ezcConsoleTableRow();

         $row->borderFormat = "foo";
         $row->format = "foo";
         $row->align = ezcConsoleTable::ALIGN_RIGHT;

         $this->assertEquals( "foo", $row->borderFormat );
         $this->assertEquals( "foo", $row->format );
         $this->assertEquals( ezcConsoleTable::ALIGN_RIGHT, $row->align );
     }

     public function testSetAccessFailure()
     {
         $row = new ezcConsoleTableRow();

         $exceptionThrown = false;
         try
         {
             $row->borderFormat = 23;
         }
         catch ( ezcBaseValueException $e )
         {
             $exceptionThrown = true;
         }
         $this->assertTrue( $exceptionThrown, "Exception not thrown on invalid value for property borderFormat." );

         $exceptionThrown = false;
         try
         {
             $row->format = 23;
         }
         catch ( ezcBaseValueException $e )
         {
             $exceptionThrown = true;
         }
         $this->assertTrue( $exceptionThrown, "Exception not thrown on invalid value for property format." );

         $exceptionThrown = false;
         try
         {
             $row->align = 23;
         }
         catch ( ezcBaseValueException $e )
         {
             $exceptionThrown = true;
         }
         $this->assertTrue( $exceptionThrown, "Exception not thrown on invalid value for property align." );

         $exceptionThrown = false;
         try
         {
             $row->foo = 23;
         }
         catch ( ezcBasePropertyNotFoundException $e )
         {
             $exceptionThrown = true;
         }
         $this->assertTrue( $exceptionThrown, "Exception not thrown on set access to invalid property foo." );
     }

     public function testIssetAccess()
     {
         $row = new ezcConsoleTableRow();
         $this->assertTrue( isset( $row->format ) );
         $this->assertTrue( isset( $row->borderFormat ) );
         $this->assertTrue( isset( $row->align ) );
         $this->assertFalse( isset( $row->foo ) );
     }

     public function testOffsetExistsSuccess()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );
         $this->assertTrue( isset( $row[0] ) );
         $this->assertTrue( isset( $row[1] ) );
         $this->assertTrue( isset( $row[2] ) );
     }

     public function testOffsetExistsFailure()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

         try
         {
             isset( $row["foo"] );
         }
         catch ( ezcBaseValueException $e )
         {
             return;
         }
         $this->fail( "Exception not thrown on invalid offset to offsetExists()." );
     }

     public function testOffsetGetSuccess()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );
         $this->assertInstanceOf( "ezcConsoleTableCell", $row[0] );
         $this->assertInstanceOf( "ezcConsoleTableCell", $row[1] );
         $this->assertInstanceOf( "ezcConsoleTableCell", $row[2] );
     }

     public function testOffsetGetFailure()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

         try
         {
              var_dump( $row["foo"] );
         }
         catch ( ezcBaseValueException $e )
         {
             return;
         }
         $this->fail( "Exception not thrown on invalid offset to offsetGet()." );
     }

     public function testOffsetSetSuccess()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );
         $newCell = new ezcConsoleTableCell();

         $row[1] = $newCell;
         $this->assertSame( $newCell, $row[1] );

         $row[] = $newCell;
         $this->assertSame( $newCell, $row[3] );
     }

     public function testOffsetSetFailure()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

         $exceptionThrown = false;
         try
         {
             $row["foo"] = new ezcConsoleTableCell();
         }
         catch ( ezcBaseValueException $e )
         {
             $exceptionThrown = true;
         }
         $this->assertTrue( $exceptionThrown, "Exception not thrown on offsetSet() with invalid offset." );

         $exceptionThrown = false;
         try
         {
             $row[1] = true;
         }
         catch ( ezcBaseValueException $e )
         {
             $exceptionThrown = true;
         }
         $this->assertTrue( $exceptionThrown, "Exception not thrown on offsetSet() with invalid value." );
     }

     public function testOffsetUnsetSuccess()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

         unset( $row[1] );

         $this->assertFalse( isset( $row[1] ) );
     }

     public function testOffsetUnsetFailure()
     {
         $row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

         try
         {
             unset( $row["foo"] );
         }
         catch ( ezcBaseValueException $e )
         {
             return;
         }
         $this->fail( "Exception not thrown on invalid offset to offsetUnset()." );
     }
 }
 ?>
	<?php
	/**
	* ezcConsoleTableRowTest class.
	*
	* 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.
	*
	* @package ConsoleTools
	* @subpackage Tests
	* @version //autogentag//
	* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
	*/

	/**
	* Test suite for ezcConsoleTableRow class.
	*
	* @package ConsoleTools
	* @subpackage Tests
	*/
	class ezcConsoleTableRowTest extends ezcTestCase
	{
	public static function suite()
	{
	return new PHPUnit_Framework_TestSuite( "ezcConsoleTableRowTest" );
	}

	public function testCtorSuccess_1()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell() );
	$this->assertEquals(
	2,
	count( $row ),
	"ezcConsoleTableRow not correctly created."
	);
	}

	public function testCtorSuccess_2()
	{
	$row = new ezcConsoleTableRow();
	$this->assertEquals(
	0,
	count( $row ),
	"ezcConsoleTableRow not correctly created."
	);
	}

	public function testCtorFailure()
	{
	$exceptionThrown = false;
	try
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), 'foo' );
	}
	catch ( ezcBaseValueException $e )
	{
	$exceptionThrown = true;
	}
	$this->assertTrue( $exceptionThrown, "Exception not thrown on invald constructor parameter." );
	}

	public function testAppend()
	{
	$row = new ezcConsoleTableRow();
	$row[]->content = 'foo';
	$this->assertTrue(
	$row[0] instanceof ezcConsoleTableCell,
	"ezcConsoleTableCell not correctly created on write access."
	);
	}

	public function testOntheflyCreationRead_1()
	{
	$row = new ezcConsoleTableRow();
	$this->assertTrue(
	$row[0] instanceof ezcConsoleTableCell,
	"ezcConsoleTableCell not correctly created on write access."
	);
	}

	public function testOntheflyCreationRead_2()
	{
	$row = new ezcConsoleTableRow();
	$row[0]; $row[1]; $row[2];
	$this->assertTrue(
	count( $row ) == 3,
	"ezcConsoleTableCell not correctly created on write access."
	);
	}

	public function testOntheflyCreationRead_3()
	{
	$row = new ezcConsoleTableRow();
	$row[0]->content = 'test';
	$row[1]->format = 'test';
	$row[2]->align = ezcConsoleTable::ALIGN_CENTER;
	$this->assertTrue(
	count($row) == 3,
	"ezcConsoleTableCell not correctly created on write access."
	);
	}

	public function testOntheflyCreationWrite_1()
	{
	$row = new ezcConsoleTableRow();
	$row[0] = new ezcConsoleTableCell();
	$row[0]->content = 'test';
	$this->assertTrue(
	count($row) == 1 && $row[0] instanceof ezcConsoleTableCell && $row[0]->content === 'test',
	"ezcConsoleTableCell not correctly created on write access."
	);
	}

	public function testNoOntheflyCreationIsset()
	{
	$row = new ezcConsoleTableRow();
	$this->assertEquals(
	isset( $row[0] ),
	false,
	"ezcConsoleTableCell created on isset access."
	);
	$this->assertEquals(
	count($row),
	0,
	"ezcConsoleTableCell created on isset access."
	);
	}

	public function testForeach_1()
	{
	$row = new ezcConsoleTableRow();
	for ( $i = 0; $i < 10; $i++ )
	{
	$row[$i]->content = 'Is '.$i;
	}
	$this->assertEquals(
	count( $row ),
	10,
	"ezcConsoleTableCells not correctly created on write access."
	);
	foreach ( $row as $id => $cell )
	{
	$this->assertEquals(
	'Is ' . $id,
	$cell->content,
	"Cell with wrong content found on iteration."
	);
	}
	}

	public function testForeach_2()
	{
	$row = new ezcConsoleTableRow();
	for ( $i = 0; $i < 20; $i += 2 )
	{
	$row[$i]->content = 'Is '.$i;
	}
	$this->assertEquals(
	count( $row ),
	19,
	"ezcConsoleTableCells."
	);
	foreach ( $row as $id => $cell );
	{
	$this->assertEquals(
	'Is ' . $id,
	$cell->content,
	"Cell with wrong content found on iteration."
	);
	}
	}

	public function testCount_1()
	{
	$row = new ezcConsoleTableRow();
	$row[0]->content = "0";
	$this->assertEquals(
	1,
	count( $row ),
	"Did not count number of cells correctly"
	);
	}

	public function testCount_2()
	{
	$row = new ezcConsoleTableRow();
	$row[1]->content = "0";
	$this->assertEquals(
	2,
	count( $row ),
	"Did not count number of cells correctly"
	);
	}

	public function testCount_3()
	{
	$row = new ezcConsoleTableRow();
	$row[10]->content = "0";
	$this->assertEquals(
	11,
	count( $row ),
	"Did not count number of cells correctly"
	);
	}

	public function testNotSetAllCellsProperties_1()
	{
	$row = new ezcConsoleTableRow();
	for ( $i = 0; $i < 10; $i++ )
	{
	$row[$i]->content = (string) $i;
	}

	$row->align = ezcConsoleTable::ALIGN_CENTER;

	foreach ( $row as $cell )
	{
	$this->assertEquals(
	ezcConsoleTable::ALIGN_DEFAULT,
	$cell->align,
	"Did not set alignment correctly for all contained cells."
	);
	}
	}

	public function testNotSetAllCellsProperties_2()
	{
	$row = new ezcConsoleTableRow();
	for ( $i = 0; $i < 10; $i++ )
	{
	$row[$i]->content = (string) $i;
	}

	$row->format = 'headline';

	foreach ( $row as $cell )
	{
	$this->assertEquals(
	'default',
	$cell->format,
	"Did not set alignment correctly for all contained cells."
	);
	}
	}

	public function testGetAccessSuccess()
	{
	$row = new ezcConsoleTableRow();
	$this->assertEquals( "default", $row->borderFormat );
	$this->assertEquals( "default", $row->format );
	$this->assertEquals( ezcConsoleTable::ALIGN_DEFAULT, $row->align );
	}

	public function testGetAccessFailure()
	{
	$row = new ezcConsoleTableRow();
	try
	{
	echo $row->foo;
	}
	catch ( ezcBasePropertyNotFoundException $e )
	{
	return;
	}
	$this->fail( "Exception not thrown on get access of invalid property foo." );
	}

	public function testSetAccessSuccess()
	{
	$row = new ezcConsoleTableRow();

	$row->borderFormat = "foo";
	$row->format = "foo";
	$row->align = ezcConsoleTable::ALIGN_RIGHT;

	$this->assertEquals( "foo", $row->borderFormat );
	$this->assertEquals( "foo", $row->format );
	$this->assertEquals( ezcConsoleTable::ALIGN_RIGHT, $row->align );
	}

	public function testSetAccessFailure()
	{
	$row = new ezcConsoleTableRow();

	$exceptionThrown = false;
	try
	{
	$row->borderFormat = 23;
	}
	catch ( ezcBaseValueException $e )
	{
	$exceptionThrown = true;
	}
	$this->assertTrue( $exceptionThrown, "Exception not thrown on invalid value for property borderFormat." );

	$exceptionThrown = false;
	try
	{
	$row->format = 23;
	}
	catch ( ezcBaseValueException $e )
	{
	$exceptionThrown = true;
	}
	$this->assertTrue( $exceptionThrown, "Exception not thrown on invalid value for property format." );

	$exceptionThrown = false;
	try
	{
	$row->align = 23;
	}
	catch ( ezcBaseValueException $e )
	{
	$exceptionThrown = true;
	}
	$this->assertTrue( $exceptionThrown, "Exception not thrown on invalid value for property align." );

	$exceptionThrown = false;
	try
	{
	$row->foo = 23;
	}
	catch ( ezcBasePropertyNotFoundException $e )
	{
	$exceptionThrown = true;
	}
	$this->assertTrue( $exceptionThrown, "Exception not thrown on set access to invalid property foo." );
	}

	public function testIssetAccess()
	{
	$row = new ezcConsoleTableRow();
	$this->assertTrue( isset( $row->format ) );
	$this->assertTrue( isset( $row->borderFormat ) );
	$this->assertTrue( isset( $row->align ) );
	$this->assertFalse( isset( $row->foo ) );
	}

	public function testOffsetExistsSuccess()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );
	$this->assertTrue( isset( $row[0] ) );
	$this->assertTrue( isset( $row[1] ) );
	$this->assertTrue( isset( $row[2] ) );
	}

	public function testOffsetExistsFailure()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

	try
	{
	isset( $row["foo"] );
	}
	catch ( ezcBaseValueException $e )
	{
	return;
	}
	$this->fail( "Exception not thrown on invalid offset to offsetExists()." );
	}

	public function testOffsetGetSuccess()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );
	$this->assertInstanceOf( "ezcConsoleTableCell", $row[0] );
	$this->assertInstanceOf( "ezcConsoleTableCell", $row[1] );
	$this->assertInstanceOf( "ezcConsoleTableCell", $row[2] );
	}

	public function testOffsetGetFailure()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

	try
	{
	var_dump( $row["foo"] );
	}
	catch ( ezcBaseValueException $e )
	{
	return;
	}
	$this->fail( "Exception not thrown on invalid offset to offsetGet()." );
	}

	public function testOffsetSetSuccess()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );
	$newCell = new ezcConsoleTableCell();

	$row[1] = $newCell;
	$this->assertSame( $newCell, $row[1] );

	$row[] = $newCell;
	$this->assertSame( $newCell, $row[3] );
	}

	public function testOffsetSetFailure()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

	$exceptionThrown = false;
	try
	{
	$row["foo"] = new ezcConsoleTableCell();
	}
	catch ( ezcBaseValueException $e )
	{
	$exceptionThrown = true;
	}
	$this->assertTrue( $exceptionThrown, "Exception not thrown on offsetSet() with invalid offset." );

	$exceptionThrown = false;
	try
	{
	$row[1] = true;
	}
	catch ( ezcBaseValueException $e )
	{
	$exceptionThrown = true;
	}
	$this->assertTrue( $exceptionThrown, "Exception not thrown on offsetSet() with invalid value." );
	}

	public function testOffsetUnsetSuccess()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

	unset( $row[1] );

	$this->assertFalse( isset( $row[1] ) );
	}

	public function testOffsetUnsetFailure()
	{
	$row = new ezcConsoleTableRow( new ezcConsoleTableCell(), new ezcConsoleTableCell(), new ezcConsoleTableCell() );

	try
	{
	unset( $row["foo"] );
	}
	catch ( ezcBaseValueException $e )
	{
	return;
	}
	$this->fail( "Exception not thrown on invalid offset to offsetUnset()." );
	}
	}
	?>