← Back to branch summary

~n-muench/+junk/podofo

« back to all changes in this revision

Viewing changes to test/unit/TokenizerTest.cpp

  • Committer: Nate Muench
  • Date: 2011-01-06 01:07:46 UTC
  • Revision ID: nowiwilldestroyabydos@gmail.com-20110106010746-aaz6xwp0pcxzj3ff
Initial Import, Version 0.8.0 SVN from Maverick

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/unit/TokenizerTest.cpp
 
1
/***************************************************************************
 
2
 *   Copyright (C) 2007 by Dominik Seichter                                *
 
3
 *   domseichter@web.de                                                    *
 
4
 *                                                                         *
 
5
 *   This program is free software; you can redistribute it and/or modify  *
 
6
 *   it under the terms of the GNU Library General Public License as       *
 
7
 *   published by the Free Software Foundation; either version 2 of the    *
 
8
 *   License, or (at your option) any later version.                       *
 
9
 *                                                                         *
 
10
 *   This program is distributed in the hope that it will be useful,       *
 
11
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 
12
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 
13
 *   GNU General Public License for more details.                          *
 
14
 *                                                                         *
 
15
 *   You should have received a copy of the GNU Library General Public     *
 
16
 *   License along with this program; if not, write to the                 *
 
17
 *   Free Software Foundation, Inc.,                                       *
 
18
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 
19
 ***************************************************************************/
 
20
 
 
21
#include "TokenizerTest.h"
 
22
 
 
23
#include <cppunit/Asserter.h>
 
24
 
 
25
using namespace PoDoFo;
 
26
 
 
27
CPPUNIT_TEST_SUITE_REGISTRATION( TokenizerTest );
 
28
 
 
29
void TokenizerTest::Test( const char* pszString, EPdfDataType eDataType, const char* pszExpected )
 
30
{
 
31
    PdfVariant  variant;
 
32
    std::string ret;
 
33
    std::string expected;
 
34
 
 
35
    expected = pszExpected ? pszExpected : pszString;
 
36
 
 
37
    printf("Testing with value: %s\n", pszString );
 
38
    PdfTokenizer tokenizer( pszString, strlen( pszString ) );
 
39
 
 
40
    tokenizer.GetNextVariant( variant, NULL );
 
41
 
 
42
    printf("   -> Expected Datatype: %i\n", eDataType );
 
43
    printf("   -> Got      Datatype: %i\n", variant.GetDataType() );
 
44
    CPPUNIT_ASSERT_EQUAL( variant.GetDataType(), eDataType );
 
45
 
 
46
    variant.ToString( ret );
 
47
    printf("   -> Convert To String: %s\n", ret.c_str() );
 
48
 
 
49
    CPPUNIT_ASSERT_EQUAL( expected, ret );
 
50
}
 
51
 
 
52
void TokenizerTest::setUp()
 
53
{
 
54
    // Nothing todo here
 
55
}
 
56
 
 
57
void TokenizerTest::tearDown()
 
58
{
 
59
    // Nothing todo here
 
60
}
 
61
 
 
62
void TokenizerTest::testArrays()
 
63
{
 
64
    Test( "[]", ePdfDataType_Array, "[ ]" );
 
65
    Test( "[ ]", ePdfDataType_Array );
 
66
    Test( "[ / ]", ePdfDataType_Array, "[ / ]" ); // empty names are legal, too!
 
67
    Test( "[ / [ ] ]", ePdfDataType_Array, "[ / [ ] ]" ); // empty names are legal, too!
 
68
    Test( "[/[]]", ePdfDataType_Array, "[ / [ ] ]" ); // empty names are legal, too!
 
69
    Test( "[ 1 2 3 4 ]", ePdfDataType_Array );
 
70
    Test( "[1 2 3 4]", ePdfDataType_Array, "[ 1 2 3 4 ]" );
 
71
    Test( "[ 2 (Hallo Welt!) 3.500000 /FMC ]", ePdfDataType_Array );
 
72
    Test( "[ [ 1 2 ] (Hallo Welt!) 3.500000 /FMC ]", ePdfDataType_Array );
 
73
    Test( "[/ImageA/ImageB/ImageC]", ePdfDataType_Array, "[ /ImageA /ImageB /ImageC ]" );
 
74
    Test( "[<530464995927cef8aaf46eb953b93373><530464995927cef8aaf46eb953b93373>]", ePdfDataType_Array, "[ <530464995927CEF8AAF46EB953B93373> <530464995927CEF8AAF46EB953B93373> ]" );
 
75
    Test( "[ 2 0 R (Test Data) 4 << /Key /Data >> 5 0 R ]", ePdfDataType_Array, "[ 2 0 R (Test Data) 4 <<\n/Key /Data\n>> 5 0 R ]" );
 
76
    Test( "[<</key/name>>2 0 R]", ePdfDataType_Array, "[ <<\n/key /name\n>> 2 0 R ]" );
 
77
    Test( "[<<//name>>2 0 R]", ePdfDataType_Array,"[ <<\n/ /name\n>> 2 0 R ]" );
 
78
    Test( "[ 27.673200 27.673200 566.256000 651.295000 ]", ePdfDataType_Array );
 
79
}
 
80
 
 
81
void TokenizerTest::testBool()
 
82
{
 
83
    Test( "false", ePdfDataType_Bool);
 
84
    Test( "true", ePdfDataType_Bool);
 
85
}
 
86
 
 
87
void TokenizerTest::testHexString()
 
88
{
 
89
    Test( "<FFEB0400A0CC>", ePdfDataType_HexString );
 
90
    Test( "<FFEB0400A0C>", ePdfDataType_HexString, "<FFEB0400A0C0>" );
 
91
    Test( "<>", ePdfDataType_HexString );
 
92
}
 
93
 
 
94
void TokenizerTest::testName()
 
95
{
 
96
    Test( "/Type", ePdfDataType_Name );
 
97
    Test( "/Length", ePdfDataType_Name );
 
98
    Test( "/Adobe#20Green", ePdfDataType_Name );
 
99
    Test( "/$$", ePdfDataType_Name );
 
100
    Test( "/1.2", ePdfDataType_Name );
 
101
    Test( "/.notdef", ePdfDataType_Name );
 
102
    Test( "/@pattern", ePdfDataType_Name );
 
103
    Test( "/A;Name_With-Various***Characters?", ePdfDataType_Name );
 
104
    Test( "/", ePdfDataType_Name ); // empty names are legal, too!
 
105
 
 
106
    // Some additional tests, which cause errors for Sebastian Loch
 
107
    
 
108
    const char* pszString = "/CheckBox#C3#9Cbersetzungshinweis";
 
109
    PdfVariant variant;
 
110
    PdfTokenizer tokenizer( pszString, strlen( pszString ) );
 
111
    tokenizer.GetNextVariant( variant, NULL );
 
112
 
 
113
    PdfName name2( variant.GetName() );
 
114
 
 
115
 
 
116
    std::ostringstream oss;
 
117
    PdfOutputDevice output(&oss);
 
118
    name2.Write(&output);
 
119
 
 
120
    CPPUNIT_ASSERT_EQUAL( variant.GetName().GetName(), name2.GetName() );
 
121
    CPPUNIT_ASSERT_EQUAL( oss.str(), std::string(pszString) );
 
122
 
 
123
    printf("!!! Name=[%s]\n", variant.GetName().GetName().c_str() );
 
124
    printf("!!! Name2=[%s]\n", name2.GetName().c_str() );
 
125
    printf("!!! oss=[%s]\n", oss.str().c_str() );
 
126
}
 
127
 
 
128
void TokenizerTest::testNull()
 
129
{
 
130
    Test( "null", ePdfDataType_Null );
 
131
}
 
132
 
 
133
void TokenizerTest::testNumbers()
 
134
{
 
135
    Test( "145", ePdfDataType_Number );
 
136
    Test( "-12", ePdfDataType_Number );    
 
137
    Test( "3.141230", ePdfDataType_Real );
 
138
    Test( "-2.970000", ePdfDataType_Real );
 
139
    Test( "0", ePdfDataType_Number );
 
140
    Test( "4.", ePdfDataType_Real, "4.000000" );
 
141
 
 
142
}
 
143
 
 
144
void TokenizerTest::testReference()
 
145
{
 
146
    Test( "2 0 R", ePdfDataType_Reference );
 
147
    Test( "3 0 R", ePdfDataType_Reference );
 
148
    Test( "4 1 R", ePdfDataType_Reference );
 
149
}
 
150
 
 
151
void TokenizerTest::testString()
 
152
{
 
153
    // testing strings
 
154
    Test( "(Hallo Welt!)", ePdfDataType_String );
 
155
    Test( "(Hallo \\(schöne\\) Welt!)", ePdfDataType_String );
 
156
    Test( "(Balanced () brackets are (ok ()) in PDF Strings)", ePdfDataType_String,
 
157
                        "(Balanced \\(\\) brackets are \\(ok \\(\\)\\) in PDF Strings)" );
 
158
    Test( "()", ePdfDataType_String );
 
159
    
 
160
    // Test octal strings
 
161
    Test( "(Test: \\064)", ePdfDataType_String, "(Test: \064)" );
 
162
    Test( "(Test: \\064\\064)", ePdfDataType_String, "(Test: \064\064)" );
 
163
    Test( "(Test: \\0645)", ePdfDataType_String, "(Test: 45)" );
 
164
    Test( "(Test: \\478)", ePdfDataType_String, "(Test: '8)" );
 
165
 
 
166
    // Test line breaks 
 
167
    Test( "(Hallo\nWelt!)", ePdfDataType_String, "(Hallo\\nWelt!)" );
 
168
    Test( "(These \\\ntwo strings \\\nare the same.)", ePdfDataType_String, 
 
169
          "(These two strings are the same.)" );
 
170
 
 
171
    // Test escape sequences
 
172
    Test( "(Hallo\\nWelt!)", ePdfDataType_String, "(Hallo\\nWelt!)" );
 
173
    Test( "(Hallo\\rWelt!)", ePdfDataType_String, "(Hallo\\rWelt!)" );
 
174
    Test( "(Hallo\\tWelt!)", ePdfDataType_String, "(Hallo\\tWelt!)" );
 
175
    Test( "(Hallo\\bWelt!)", ePdfDataType_String, "(Hallo\\bWelt!)" );
 
176
    Test( "(Hallo\\fWelt!)", ePdfDataType_String, "(Hallo\\fWelt!)" );
 
177
}
 
178
 
 
179
void TokenizerTest::testDictionary() 
 
180
{
 
181
    const char* pszDictIn = 
 
182
        "<< /CheckBox#C3#9Cbersetzungshinweis(False)/Checkbox#C3#9Cbersetzungstabelle(False) >>";
 
183
    const char* pszDictOut = 
 
184
        "<<\n/CheckBox#C3#9Cbersetzungshinweis (False)\n/Checkbox#C3#9Cbersetzungstabelle (False)\n>>";
 
185
 
 
186
    Test( pszDictIn, ePdfDataType_Dictionary, pszDictOut );
 
187
}
 
188
 
 
189
void TokenizerTest::TestStream( const char* pszBuffer, const char* pszTokens[] )
 
190
{
 
191
 
 
192
    long          lLen = strlen( pszBuffer );
 
193
    PdfTokenizer  tokenizer( pszBuffer, lLen );
 
194
    EPdfTokenType eType;
 
195
    const char*   pszCur;
 
196
    int           i = 0;
 
197
    while( pszTokens[i] )
 
198
    {
 
199
        CPPUNIT_ASSERT_EQUAL( tokenizer.GetNextToken( pszCur, &eType ), true );
 
200
        
 
201
        std::string sCur( pszCur );
 
202
        std::string sToken( pszTokens[i] );
 
203
 
 
204
        CPPUNIT_ASSERT_EQUAL( sCur, sToken );
 
205
 
 
206
        ++i;
 
207
    }
 
208
 
 
209
    // We are at the end, so GetNextToken has to return false!
 
210
    CPPUNIT_ASSERT_EQUAL( tokenizer.GetNextToken( pszCur, &eType ), false );
 
211
}
 
212
 
 
213
void TokenizerTest::TestStreamIsNextToken( const char* pszBuffer, const char* pszTokens[] )
 
214
{
 
215
 
 
216
    long          lLen = strlen( pszBuffer );
 
217
    PdfTokenizer  tokenizer( pszBuffer, lLen );
 
218
 
 
219
    int           i = 0;
 
220
    while( pszTokens[i] )
 
221
        CPPUNIT_ASSERT_EQUAL( tokenizer.IsNextToken( pszTokens[i++] ), true );
 
222
}
 
223
 
 
224
void TokenizerTest::testTokens()
 
225
{
 
226
    const char* pszBuffer = "613 0 obj"
 
227
        "<< /Length 141 /Filter [ /ASCII85Decode /FlateDecode ] >>"
 
228
        "endobj";
 
229
 
 
230
    const char* pszTokens[] = {
 
231
        "613", "0", "obj", "<<", "/", "Length", "141", "/", "Filter", "[", "/",
 
232
        "ASCII85Decode", "/", "FlateDecode", "]", ">>", "endobj", NULL
 
233
    };
 
234
 
 
235
    TestStream( pszBuffer, pszTokens );
 
236
    TestStreamIsNextToken( pszBuffer, pszTokens );
 
237
}
 
238
 
 
239
void TokenizerTest::testComments()
 
240
{
 
241
    const char* pszBuffer = "613 0 obj\n"
 
242
        "% A comment that should be ignored\n"
 
243
        "<< /Length 141 /Filter\n% A comment in a dictionary\n[ /ASCII85Decode /FlateDecode ] >>"
 
244
        "endobj";
 
245
 
 
246
    const char* pszTokens[] = {
 
247
        "613", "0", "obj", "<<", "/", "Length", "141", "/", "Filter", "[", "/",
 
248
        "ASCII85Decode", "/", "FlateDecode", "]", ">>", "endobj", NULL
 
249
    };
 
250
 
 
251
    TestStream( pszBuffer, pszTokens );
 
252
    TestStreamIsNextToken( pszBuffer, pszTokens );
 
253
}
 
254
 
 
255
void TokenizerTest::testLocale()
 
256
{
 
257
    // Test with a locale thate uses "," instead of "." for doubles 
 
258
    char *old = setlocale( LC_ALL, "de_DE" ); 
 
259
 
 
260
    const char* pszNumber = "3.140000";
 
261
    Test( pszNumber, ePdfDataType_Real, pszNumber );
 
262
 
 
263
    setlocale( LC_ALL, old );
 
264
}