BibTexTest.php

Go to the documentation of this file.

<?php
  // Call Structures_BibTexTest::main() if this source file is executed directly.
if (!defined("PHPUnit_MAIN_METHOD")) {
    define("PHPUnit_MAIN_METHOD", "BibTexTest::main");
 }

require_once "PHPUnit/Framework/TestCase.php";
require_once "PHPUnit/Framework/TestSuite.php";

// You may remove the following line when all tests have been implemented.
require_once "PHPUnit/Framework/IncompleteTestError.php";

require_once "Structures/BibTex.php";
require_once "PEAR.php";

class BibTexTest extends PHPUnit_Framework_TestCase
{
    var $obj;

    public static function main() {
        require_once "PHPUnit/TextUI/TestRunner.php";
        $suite  = new PHPUnit_Framework_TestSuite("Structures_BibTexTest");
        $result = PHPUnit_TextUI_TestRunner::run($suite);
    }

    protected function setUp() {
        $this->obj = new Structures_BibTex();
    }

    protected function tearDown() {
        unset($this->obj);
    }

    public function testLoadFileFileExists() {
        $ret = $this->obj->loadFile("BibTexTest.php");
        $this->content = ''; //Erasing the loaded content again because it is senseless
        $this->assertTrue($ret);
    }

    public function testLoadFileFileDoesNotExists() {
        $ret = $this->obj->loadFile((string)time());
        $this->assertTrue(PEAR::isError($ret));
    }

    public function test_parseEntry() {
        //Remember here that there is no closing brace!
        $test                  = "@foo{bar,john=doe";
        $shouldbe              = array();
        $shouldbe['john']      = 'doe';
        $shouldbe['cite']      = 'bar';
        $shouldbe['entryType'] = 'foo';
        $this->assertEquals($shouldbe, $this->obj->_parseEntry($test));
    }

    public function test_checkEqualSignTrue() {
        $test = "={=}";
        $this->assertTrue($this->obj->_checkEqualSign($test,0));
    }
    public function test_checkEqualSignFalse() {
        $test = "={=}";
        $this->assertFalse($this->obj->_checkEqualSign($test,2));
    }

    public function testClearWarnings() {
        $this->obj->clearWarnings();
        $this->obj->_generateWarning('type', 'entry');
        $this->obj->clearWarnings();
        $this->assertFalse($this->obj->hasWarning());
    }

    /*
     * the next tests check for the generation of the following Warnings:
     * - WARNING_AT_IN_BRACES
     * - WARNING_ESCAPED_DOUBLE_QUOTE_INSIDE_DOUBLE_QUOTES
     * - WARNING_UNBALANCED_AMOUNT_OF_BRACES
     */
    public function test_validateValueWarningAtInBraces() {
        $this->obj->clearWarnings();
        $test = '{john@doe}';
        $this->obj->_validateValue($test, '');
        $this->assertEquals('WARNING_AT_IN_BRACES', $this->obj->warnings[0]['warning']);
    }
    public function test_validateValueWarningEscapedDoubleQuoteInsideDoubleQuotes() {
        $this->obj->clearWarnings();
        $test = '"john\"doe"';
        $this->obj->_validateValue($test, '');
        $this->assertEquals('WARNING_ESCAPED_DOUBLE_QUOTE_INSIDE_DOUBLE_QUOTES', $this->obj->warnings[0]['warning']);
    }
    public function test_validateValueWarningUnbalancedAmountOfBracesOpen() {
        $this->obj->clearWarnings();
        $test = '{john{doe}';
        $this->obj->_validateValue($test, '');
        $this->assertEquals('WARNING_UNBALANCED_AMOUNT_OF_BRACES', $this->obj->warnings[0]['warning']);
    }
    public function test_validateValueWarningUnbalancedAmountOfBracesClosed() {
        $this->obj->clearWarnings();
        $test = '{john}doe}';
        $this->obj->_validateValue($test, '');
        $this->assertEquals('WARNING_UNBALANCED_AMOUNT_OF_BRACES', $this->obj->warnings[0]['warning']);
    }

    public function test_generateWarning() {
        $this->obj->clearWarnings();
        $this->obj->_generateWarning('type', 'entry');
        $ret = $this->obj->hasWarning();
        $this->obj->clearWarnings();
        $this->assertTrue($ret);
    }

    public function testHasWarning()
    {
        $this->obj->clearWarnings();
        $this->assertFalse($this->obj->hasWarning());
    }

    public function testAmount()
    {
        $teststring = "@Article {art1,author = {John Doe and Jane Doe}}@Article { art2,author = {John Doe and Jane Doe}}";
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->assertEquals(2, $this->obj->amount());
    }

    public function testGetStatistic()
    {
        $teststring = "@Article {art1,author = {John Doe and Jane Doe}}@Article { art2,author = {John Doe and Jane Doe}}";
        $this->obj->content = $teststring;
        $this->obj->parse();
        $shouldbe            = array();
        $shouldbe['article'] = 2;
        $this->assertEquals($shouldbe, $this->obj->getStatistic());
    }

    function testSingleParse()
    {
        $teststring="@Article { ppm_jon:1991,
author = {John Doe and Jane Doe}
}";
        $this->obj->content=$teststring;
        $this->obj->parse();
        $this->assertEquals(1,$this->obj->amount());
    }

    function testMultiParse()
    {
        $teststring = "@Article { art1,
author = {John Doe and Jane Doe}
}
@Article { art2,
author = {John Doe and Jane Doe}
}";
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->assertEquals(2,$this->obj->amount());
    }

    function testParse()
    {
        $teststring = "@Article { art1,
title = {Titel1},
author = {John Doe and Jane Doe}
}";
        $shouldbe = array();
        $shouldbe[0]['entryType'] = 'article';
        $shouldbe[0]['cite']      = 'art1';
        $shouldbe[0]['title']     = 'Titel1';
        $shouldbe[0]['author'][0]['first'] = 'John';
        $shouldbe[0]['author'][0]['von']   = '';
        $shouldbe[0]['author'][0]['last']  = 'Doe';
        $shouldbe[0]['author'][0]['jr']    = '';
        $shouldbe[0]['author'][1]['first'] = 'Jane';
        $shouldbe[0]['author'][1]['von']   = '';
        $shouldbe[0]['author'][1]['last']  = 'Doe';
        $shouldbe[0]['author'][1]['jr']    = '';
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->assertEquals($shouldbe,$this->obj->data);
    }

    function testBibTex()
    {
        $testarray = array();
        $testarray[0]['entryType'] = 'Article';
        $testarray[0]['cite']      = 'art1';
        $testarray[0]['title']     = 'Titel1';
        $testarray[0]['author'][0]['first'] = 'John';
        $testarray[0]['author'][0]['von']   = '';
        $testarray[0]['author'][0]['last']  = 'Doe';
        $testarray[0]['author'][0]['jr']    = '';
        $testarray[0]['author'][1]['first'] = 'Jane';
        $testarray[0]['author'][1]['von']   = '';
        $testarray[0]['author'][1]['last']  = 'Doe';
        $testarray[0]['author'][1]['jr']    = '';
        $shouldbe = "@article { art1,\n\ttitle = {Titel1},\n\tauthor = {Doe, , John and Doe, , Jane}\n}";
        $this->obj->data = $testarray;
        $this->assertEquals(trim($shouldbe),trim($this->obj->bibTex()));
    }

    function testAddEntry()
    {
        $addarray = array();
        $addarray['type'] = 'Article';
        $addarray['cite'] = 'art2';
        $addarray['title'] = 'Titel2';
        $addarray['author'][0] = 'John Doe';
        $addarray['author'][1] = 'Jane Doe';
        $teststring = "@Article { art1,
title = {Titel1},
author = {John Doe and Jane Doe}
}";
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->obj->addEntry($addarray);
        $this->assertEquals(2,$this->obj->amount());
    }

    function testEntryOverMoreLines()
    {
        //Entry found at http://en.wikipedia.org/wiki/BibTeX
        $teststring = "@Book{abramowitz+stegun,
  author =       \"Milton Abramowitz and Irene A. Stegun\",
  title =        \"Handbook of Mathematical Functions with
                  Formulas, Graphs, and Mathematical Tables\",
  publisher =    \"Dover\",
  year =         1964,
  address =      \"New York\",
  edition =      \"ninth Dover printing, tenth GPO printing\",
  isbn =         \"0-486-61272-4\"
}";
        $shouldbe = array();
        $shouldbe[0]['entryType']  = 'book';
        $shouldbe[0]['cite']       = 'abramowitz+stegun';
        $shouldbe[0]['title']      = "Handbook of Mathematical Functions with
                  Formulas, Graphs, and Mathematical Tables";
        $shouldbe[0]['author'][0]['first'] = 'Milton';
        $shouldbe[0]['author'][0]['von']   = '';
        $shouldbe[0]['author'][0]['last']  = 'Abramowitz';
        $shouldbe[0]['author'][0]['jr']    = '';
        $shouldbe[0]['author'][1]['first'] = 'Irene A.';
        $shouldbe[0]['author'][1]['von']   = '';
        $shouldbe[0]['author'][1]['last']  = 'Stegun';
        $shouldbe[0]['author'][1]['jr']    = '';
        $shouldbe[0]['publisher'] = 'Dover';
        $shouldbe[0]['year']      = '1964';
        $shouldbe[0]['address']   = 'New York';
        $shouldbe[0]['edition']   = 'ninth Dover printing, tenth GPO printing';
        $shouldbe[0]['isbn']      = '0-486-61272-4';
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->assertEquals($shouldbe, $this->obj->data);
    }

    function testParsingComment()
    {
        $teststring = "@Article { art1,
title = {Titel1},
author = {John Doe and Jane Doe}
}
Here is a comment
@Article { art2,
title = {Titel2},
author = {John Doe and Jane Doe}
}";
        $shouldbe = array();
        $shouldbe[0]['entryType'] = 'article';
        $shouldbe[0]['cite']      = 'art1';
        $shouldbe[0]['title']     = 'Titel1';
        $shouldbe[0]['author'][0]['first'] = 'John';
        $shouldbe[0]['author'][0]['von']   = '';
        $shouldbe[0]['author'][0]['last']  = 'Doe';
        $shouldbe[0]['author'][0]['jr']    = '';
        $shouldbe[0]['author'][1]['first'] = 'Jane';
        $shouldbe[0]['author'][1]['von']   = '';
        $shouldbe[0]['author'][1]['last']  = 'Doe';
        $shouldbe[0]['author'][1]['jr']    = '';
        $shouldbe[1]['entryType'] = 'article';
        $shouldbe[1]['cite']      = 'art2';
        $shouldbe[1]['title']     = 'Titel2';
        $shouldbe[1]['author'][0]['first'] = 'John';
        $shouldbe[1]['author'][0]['von']   = '';
        $shouldbe[1]['author'][0]['last']  = 'Doe';
        $shouldbe[1]['author'][0]['jr']    = '';
        $shouldbe[1]['author'][1]['first'] = 'Jane';
        $shouldbe[1]['author'][1]['von']   = '';
        $shouldbe[1]['author'][1]['last']  = 'Doe';
        $shouldbe[1]['author'][1]['jr']    = '';
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->assertTrue($this->obj->data == $shouldbe);
    }
    /*
         function testWrongBraces1() {
         $teststring = "@Article { art1,
         title = {Tit}el1},
         author = {John Doe and Jane Doe}
         }";
        $this->obj->content = $teststring;
         $this->assertTrue(PEAR::isError($this->obj->parse()));
         }

         function testWrongBraces2() {
         $teststring = "@Article { art1,
         title = {Titel1},
         author = {John Doe and }Jane }Doe}
         }";
         $this->obj->content = $teststring;
         $this->assertTrue(PEAR::isError($this->obj->parse()));
         }
    */
    function testWrongBraces3() {
        $teststring = "@Article { art1,
title = {Titel1},
author = {John {Doe and {Jane Doe}
}";
        $this->obj->content = $teststring;
        $this->assertTrue(PEAR::isError($this->obj->parse()));
    }

    function testWarningAtInBraces() {
        $teststring = "@Article { art1,
title = {Titel1},
author = {John Doe and @Jane Doe}
}";
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->assertTrue('WARNING_AT_IN_BRACES'==$this->obj->warnings[0]['warning']);
    }
    function testWarningEscapedDoubleQuote() {
        $teststring = "@Article { art1,
title = {Titel1},
author = \"John Doe and \\\"Jane Doe\"
}";
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->assertTrue('WARNING_ESCAPED_DOUBLE_QUOTE_INSIDE_DOUBLE_QUOTES'==$this->obj->warnings[0]['warning']);
    }
    /*
         function testWarningAmountBraces() {
         $teststring = "@Article { art1,
         title = {Tit{el1},
         author = {John Doe and }Jane Doe}
         }";
         $this->obj->content = $teststring;
         $this->obj->parse();
         $this->assertTrue('WARNING_UNBALANCED_AMOUNT_OF_BRACES'==$this->obj->warnings[0]['warning']);
         }
    */
    function testWarningMultipleEntries() {
        $teststring = "@Article { art1,
title = {Titel1},
author = {John Doe and Jane Doe}
}
@Article { art2,
title = {Titel1},
author = {John Doe and Jane Doe}
}
@Article { art1,
title = {Titel1},
author = {John Doe and Jane Doe}
}
@Article { art2,
title = {Titel1},
author = {John Doe and Jane Doe}
}
@Article { art3,
title = {Titel1},
author = {John Doe and Jane Doe}
}";
        $this->obj->content = $teststring;
        $this->obj->parse();
        $this->assertTrue('WARNING_MULTIPLE_ENTRIES'==$this->obj->warnings[0]['warning']);
    }

    /* This testing suite is needed to get the Authors correct.
     for more information: http://artis.imag.fr/%7EXavier.Decoret/resources/xdkbibtex/bibtex_summary.html
     The names of the functions are build as follows:
     "test": Of course it is a unit test
     "Author": Function testing the authors
     "First": There are three different ways writing an author this is the first one
     "Simple": Description of the tes
    */
    function testAuthorFirstSimple() {
        $test     = "AA BB";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'BB';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    
    function testAuthorFirstLastCannotBeEmpty() {
        $test     = "AA";
        $shouldbe = array();
        $shouldbe[0]['first'] = '';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'AA';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    
    function testAuthorFirstSimpleLowerCase() {
        $test     = "AA bb";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'bb';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    
    function testAuthorFirstLastCannotBeEmptyLowerCase() {
        $test     = "aa";
        $shouldbe = array();
        $shouldbe[0]['first'] = '';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'aa';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    
    function testAuthorFirstSimpleVon() {
        $test     = "AA bb CC";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = 'bb';
        $shouldbe[0]['last']  = 'CC';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstSimpleVonInnerUppercase() {
        $test     = "AA bb CC dd EE";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = 'bb CC dd';
        $shouldbe[0]['last']  = 'EE';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstDigitsArecaselessUppercase() {
        $test     = "AA 1B cc dd";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA 1B';
        $shouldbe[0]['von']   = 'cc';
        $shouldbe[0]['last']  = 'dd';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstDigitsArecaselessLowercase() {
        $test     = "AA 1b cc dd";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = '1b cc';
        $shouldbe[0]['last']  = 'dd';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstPseudoLettersAreCaselessLowerInsideUpperOutside() {
        $test     = "AA {b}B cc dd";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA {b}B';
        $shouldbe[0]['von']   = 'cc';
        $shouldbe[0]['last']  = 'dd';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstPseudoLettersAreCaselessLowerInsideLowerOutside() {
        $test     = "AA {b}b cc dd";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = '{b}b cc';
        $shouldbe[0]['last']  = 'dd';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstPseudoLettersAreCaselessUpperInsideUpperOutside() {
        $test     = "AA {B}B cc dd";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA {B}B';
        $shouldbe[0]['von']   = 'cc';
        $shouldbe[0]['last']  = 'dd';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstPseudoLettersAreCaselessUpperInsideLowerOutside() {
        $test     = "AA {B}b cc dd";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = '{B}b cc';
        $shouldbe[0]['last']  = 'dd';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstNonLettersAreCaselessUpperCase() {
        $test     = "AA \BB{b} cc dd";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA \BB{b}';
        $shouldbe[0]['von']   = 'cc';
        $shouldbe[0]['last']  = 'dd';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstNonLettersAreCaselessLowerCase() {
        $test     = "AA \bb{b} cc dd";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = '\bb{b} cc';
        $shouldbe[0]['last']  = 'dd';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstGroupingCaselessOne() {
        $test     = "AA {bb} cc DD";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA {bb}';
        $shouldbe[0]['von']   = 'cc';
        $shouldbe[0]['last']  = 'DD';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstGroupingCaselessTwo() {
        $test     = "AA bb {cc} DD";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = 'bb';
        $shouldbe[0]['last']  = '{cc} DD';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorFirstGroupingCaselessThree() {
        $test     = "AA {bb} CC";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA {bb}';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'CC';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorSecondAndThirdSimpleCaseFirstUppercase() {
        $test     = "bb CC, AA";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = 'bb';
        $shouldbe[0]['last']  = 'CC';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorSecondAndThirdSimpleCaseFirstLowercase() {
        $test     = "bb CC, aa";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'aa';
        $shouldbe[0]['von']   = 'bb';
        $shouldbe[0]['last']  = 'CC';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorSecondAndThirdSimpleVon() {
        $test     = "bb CC dd EE, AA";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = 'bb CC dd';
        $shouldbe[0]['last']  = 'EE';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorSecondAndThirdLastPartCoannotBeEmpty() {
        $test     = "bb, AA";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'bb';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorSecondAndThirdFirstCanBeEmptyAfterComma() {
        $test     = "BB,";
        $shouldbe = array();
        $shouldbe[0]['first'] = '';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'BB';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorSecondAndThirdSimpleJrUppercase() {
        $test     = "bb CC,XX, AA";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = 'bb';
        $shouldbe[0]['last']  = 'CC';
        $shouldbe[0]['jr']    = 'XX';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorSecondAndThirdSimpleJrLowercase() {
        $test     = "bb CC,xx, AA";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = 'bb';
        $shouldbe[0]['last']  = 'CC';
        $shouldbe[0]['jr']    = 'xx';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    function testAuthorSecondAndThirdJrCanBeEmptyBetweenCommas() {
        $test     = "BB,, AA";
        $shouldbe = array();
        $shouldbe[0]['first'] = 'AA';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'BB';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    /*Testing the case determination needed for the authors*/
    function testCaseUpperSimple() {
        $test = 'AA';
        $this->assertEquals(1, $this->obj->_determineCase($test));
    }
    function testCaseLowerSimple() {
        $test = 'aa';
        $this->assertEquals(0, $this->obj->_determineCase($test));
    }
    function testCaseCaselessSimple() {
        $test = '{a}';
        $this->assertEquals(-1, $this->obj->_determineCase($test));
    }
    function testCaseUpperComplexBrace() {
        $test = '{A}A';
        $this->assertEquals(1, $this->obj->_determineCase($test));
    }
    function testCaseLowerComplexBrace() {
        $test = '{a}a';
        $this->assertEquals(0, $this->obj->_determineCase($test));
    }
    function testCaseUpperComplexNumber() {
        $test = '1A';
        $this->assertEquals(1, $this->obj->_determineCase($test));
    }
    function testCaseLowerComplexNumber() {
        $test = '1a';
        $this->assertEquals(0, $this->obj->_determineCase($test));
    }
    function testCaseUpperComplexWhitespace() {
        $test = ' A';
        $this->assertEquals(1, $this->obj->_determineCase($test));
    }
    function testCaseLowerComplexWhitespace() {
        $test = ' a';
        $this->assertEquals(0, $this->obj->_determineCase($test));
    }
    function testCaseErrorEmptyString() {
        $test = '';
        $this->assertTrue(PEAR::isError($this->obj->_determineCase($test)));
    }
    function testCaseErrorNonString() {
        $test = 2;
        $this->assertTrue(PEAR::isError($this->obj->_determineCase($test)));
    }
    
    function testAllowedTypeTrue() {
        $test = 'article';
        $this->assertTrue($this->obj->_checkAllowedEntryType($test));
    }
    function testAllowedTypeFalse() {
        $test = 'foo';
        $this->assertFalse($this->obj->_checkAllowedEntryType($test));
    }
    
    public function testAllowedTypeWarning() {
        $this->obj->clearWarnings();
        $test = "@Foo { art1,
title = {Titel1},
author = {John Doe and Jane Doe}
}";
        $this->obj->content = $test;
        $this->obj->setOption('validate', true);
        $this->obj->parse();
        $this->assertEquals('WARNING_NOT_ALLOWED_ENTRY_TYPE', $this->obj->warnings[0]['warning']);
    }
    
    public function testMissingLastBraceParsing() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo1,
school = {school1},
title = {title1},
author = {author1},
year = {year1}
}
@phdthesis{foo2,
school = {school2},
title = {title2},
author = {author2},
year = {year2}

@phdthesis{foo3,
school = {school3},
title = {title3},
author = {author3},
year = {year3}
}
@phdthesis{foo4,
school = {school4},
title = {title4},
author = {author4},
year = {year4}
}
        ';
        $this->obj->content = $test;
        $this->obj->setOption('validate', true);
        $this->obj->parse();
        $this->assertEquals($this->obj->amount(), 4);
    }

    public function testMissingLastBraceParsing2() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo1,
school = {school1},
title = {title1},
author = {author1},
year = {year1}
        ';
        $this->obj->content = $test;
        $this->obj->setOption('validate', true);
        $this->obj->parse();
        $this->assertEquals($this->obj->amount(), 1);
    }
    
    public function testMissingLastBraceWarning() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo1,
school = {school1},
title = {title1},
author = {author1},
year = {year1}
}
@phdthesis{foo2,
school = {school2},
title = {title2},
author = {author2},
year = {year2}

@phdthesis{foo3,
school = {school3},
title = {title3},
author = {author3},
year = {year3}
}
@phdthesis{foo4,
school = {school4},
title = {title4},
author = {author4},
year = {year4}
}
        ';
        $this->obj->content = $test;
        $this->obj->setOption('validate', true);
        $this->obj->parse();
        $this->assertEquals($this->obj->warnings[0]['warning'], 'WARNING_MISSING_END_BRACE');
    }

    public function testNewlineInAuthorField() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo1,
school = {school1},
title = {title1},
author = {author1 and
author2},
year = {year1}
}
        ';
        $shouldbe = array(array('first'=>'','von'=>'','last'=>'author1','jr'=>''), array('first'=>'','von'=>'','last'=>'author2','jr'=>''));
        $this->obj->content = $test;
        $this->obj->setOption('unwrap', false);
        $this->obj->parse();
        $this->assertEquals($shouldbe, $this->obj->data[0]['author']);
    }

    public function testNotRemoveCurlyBraces() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo4,
school = {school4},
title = {Do {S}omething},
author = {author4},
year = {year4}
}
        ';
        $shouldbe = 'Do {S}omething';
        $this->obj->content = $test;
        $this->obj->setOption('removeCurlyBraces', false);
        $this->obj->parse();
        //print_r($this->obj->data[0]['author']);
        $this->assertEquals($shouldbe, $this->obj->data[0]['title']);
    }
    
    public function testRemoveCurlyBraces() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo4,
school = {school4},
title = {Do {S}omething},
author = {author4},
year = {year4}
}
        ';
        $shouldbe = 'Do Something';
        $this->obj->content = $test;
        $this->obj->setOption('removeCurlyBraces', true);
        $this->obj->parse();
        //print_r($this->obj->data[0]['author']);
        $this->assertEquals($shouldbe, $this->obj->data[0]['title']);
    }

    public function testRemoveCurlyBraces2() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo4,
school = {school4},
title = {Do {S}o{me\}th}ing},
author = {author4},
year = {year4}
}
        ';
        $shouldbe = 'Do Some\}thing';
        $this->obj->content = $test;
        $this->obj->setOption('removeCurlyBraces', true);
        $this->obj->parse();
        $this->assertEquals($shouldbe, $this->obj->data[0]['title']);
    }

    public function testRemoveCurlyBracesWithoutBraces() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo4,
school = {school4},
title = {Do Something},
author = {author4},
year = {year4}
}
        ';
        $shouldbe = 'Do Something';
        $this->obj->content = $test;
        $this->obj->setOption('removeCurlyBraces', true);
        $this->obj->parse();
        $this->assertEquals($shouldbe, $this->obj->data[0]['title']);
    }
    
    public function testRtfExport() {
        $test = '
@phdthesis{foo4,
title = {title},
author = {author},
journal = {journal},
year = {year}
}
        ';
        $shouldbe = '{\rtf
author title journal year
\par
}';
        $this->obj->content      = $test;
        /*Setting formating option and saving old state*/
        $oldrtfstring            = $this->obj->rtfstring;
        $this->obj->rtfstring    = 'AUTHORS TITLE JOURNAL YEAR';
        $oldauthorstring         = $this->obj->authorstring;
        $this->obj->authorstring = 'LAST';
        $this->obj->parse();
        
        $rtf = $this->obj->rtf();
        /*Resetting old state*/
        $this->obj->rtfstring    = $oldrtfstring;
        $this->obj->authorstring = $oldauthorstring;
        
        $this->assertEquals($shouldbe, $rtf);
    }

    public function testHtmlExport() {
        $test = '
@phdthesis{foo4,
title = {title},
author = {author},
journal = {journal},
year = {year}
}
        ';
        $shouldbe = '<p>
author title journal year
</p>
';
        $this->obj->content      = $test;
        /*Setting formating option and saving old state*/
        $oldhtmlstring           = $this->obj->htmlstring;
        $this->obj->htmlstring   = 'AUTHORS TITLE JOURNAL YEAR';
        $oldauthorstring         = $this->obj->authorstring;
        $this->obj->authorstring = 'LAST';
        $this->obj->parse();
        
        $html = $this->obj->html();
        /*Resetting old state*/
        $this->obj->htmlstring   = $oldhtmlstring;
        $this->obj->authorstring = $oldauthorstring;
        
        $this->assertEquals($shouldbe, $html);
    }

    public function testFormatAuthor() {
        $test = '
@phdthesis{foo4,
author = {von Last, Jr ,First}
}
        ';
        $shouldbe = 'von Last Jr First';
        $this->obj->content      = $test;
        /*Setting formating option and saving old state*/
        $oldhtmlstring           = $this->obj->htmlstring;
        $this->obj->htmlstring   = 'AUTHORS';
        $oldauthorstring         = $this->obj->authorstring;
        $this->obj->authorstring = 'VON LAST JR FIRST';
        $this->obj->parse();
        
        $html = $this->obj->html();
        /*Dropping tags and trimming*/
        $html = trim(strip_tags($html));
        /*Resetting old state*/
        $this->obj->htmlstring   = $oldhtmlstring;
        $this->obj->authorstring = $oldauthorstring;
        
        $this->assertEquals($shouldbe, $html);
    }
    
    public function testExtractAuthorWhitespace() {
        $test = 'John Doe';
        $shouldbe = array();
        $shouldbe[0]['first'] = 'John';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'Doe';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }

    public function testExtractAuthorTilde() {
        $test = 'John~Doe';
        $shouldbe = array();
        $shouldbe[0]['first'] = 'John';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'Doe';
        $shouldbe[0]['jr']    = '';
        $this->assertEquals($shouldbe, $this->obj->_extractAuthors($test));
    }
    
    public function testNotExtractAuthors() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo4,
author = {John Doe},
}
        ';
        $shouldbe = 'John Doe';
        $this->obj->content = $test;
        $this->obj->setOption('extractAuthors', false);
        $this->obj->parse();
        $this->assertEquals($shouldbe, $this->obj->data[0]['author']);
    }

    public function testExtractAuthors() {
        $this->obj->clearWarnings();
        $test = '
@phdthesis{foo4,
author = {John Doe},
}
        ';
        $shouldbe = array();
        $shouldbe[0]['first'] = 'John';
        $shouldbe[0]['von']   = '';
        $shouldbe[0]['last']  = 'Doe';
        $shouldbe[0]['jr']    = '';
        $this->obj->content = $test;
        $this->obj->setOption('extractAuthors', true);
        $this->obj->parse();
        $this->assertEquals($shouldbe, $this->obj->data[0]['author']);
    }
    
    public function testNotExtractAuthorsBibtexExport() {
        $this->obj->clearWarnings();
        $test = "@phdthesis { foo4,\n\tauthor = {John Doe}\n}\n\n";
        $this->obj->content = $test;
        $this->obj->setOption('extractAuthors', false);
        $this->obj->parse();
        $this->assertEquals($test, $this->obj->bibTex());
    }

    public function testNotExtractAuthorsRtfExport() {
        $this->obj->clearWarnings();
        $test = "@phdthesis { foo4,\n\tauthor = {John Doe}\n}\n\n";
        $shouldbe = '{\rtf
John Doe, "{\b }", {\i }, 
\par
}';
        $this->obj->content = $test;
        $this->obj->setOption('extractAuthors', false);
        $this->obj->parse();
        $this->assertEquals($shouldbe, $this->obj->rtf());
    }

    public function testNotExtractAuthorsHtmlExport() {
        $this->obj->clearWarnings();
        $test = "@phdthesis { foo4,\n\tauthor = {John Doe}\n}\n\n";
        $shouldbe = '<p>
John Doe, "<strong></strong>", <em></em>, <br />
</p>
';
        $this->obj->content = $test;
        $this->obj->setOption('extractAuthors', false);
        $this->obj->parse();
        $this->assertEquals($shouldbe, $this->obj->html());
    }
}

// Call Structures_BibTexTest::main() if this source file is executed directly.
if (PHPUnit_MAIN_METHOD == "BibTexTest::main") {
    BibTexTest::main();
 }
?>