source: icXML/icXML-devel/tests/src/UtilTests/CoreTests_URL.cpp @ 2726

Last change on this file since 2726 was 2726, checked in by cameron, 7 years ago

Add original Xerces tests and samples directories

File size: 11.1 KB
RevLine 
[2726]1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: CoreTests_URL.cpp 470088 2006-11-01 20:35:12Z amassari $
20 */
21
22// ---------------------------------------------------------------------------
23//  XML4C2 includes
24// ---------------------------------------------------------------------------
25#include <xercesc/util/RuntimeException.hpp>
26#include <xercesc/util/XMLURL.hpp>
27#include "CoreTests.hpp"
28
29
30
31// ---------------------------------------------------------------------------
32//  Local testing functions
33// ---------------------------------------------------------------------------
34
35//
36//  This test just sets up a list of variations on URLs and parses them. The
37//  URL list includes the expected text for each of the parts that should be
38//  parsed out of the URL.
39//
40struct BasicTestEntry
41{
42    const XMLCh*        orgURL;
43    const XMLCh*        fullText;
44    XMLURL::Protocols   protocol;
45    unsigned int        portNum;
46    const XMLCh*        fragment;
47    const XMLCh*        host;
48    const XMLCh*        path;
49    const XMLCh*        password;
50    const XMLCh*        query;
51    const XMLCh*        user;
52};
53
54static bool checkAField(const   XMLCh* const test
55                        , const XMLCh* const expected
56                        , const XMLCh* const fieldName)
57{
58    if (!test && !expected)
59        return true;
60
61    if (!test && expected)
62    {
63        XERCES_STD_QUALIFIER wcout << L"Expected value for the " << fieldName
64                   << " field was not present" << XERCES_STD_QUALIFIER endl;
65        return false;
66    }
67     else if (test && !expected)
68    {
69        XERCES_STD_QUALIFIER wcout << L"The value '" << test << L"' for the " << fieldName
70                   << L" was not expected" << XERCES_STD_QUALIFIER endl;
71        return false;
72    }
73     else if (XMLString::compareString(test, expected))
74    {
75        XERCES_STD_QUALIFIER wcout  << L"Expected: " << expected << L", but got: " << test
76                    << XERCES_STD_QUALIFIER endl;
77        return false;
78    }
79    return true;
80}
81
82static bool checkBasicResult(const  XMLURL&         testURL
83                            , const BasicTestEntry& testInfo)
84{
85    //
86    //  Check each part to insure that its what its supposed to be. Since
87    //  any of them can be a null pointer, we have a little helper function
88    //  that spits out the actual testing code for each one.
89    //
90    if (!checkAField(testURL.getURLText(), testInfo.fullText, L"Full Text"))
91        return false;
92
93    if (!checkAField(testURL.getFragment(), testInfo.fragment, L"Fragment"))
94        return false;
95
96    if (!checkAField(testURL.getHost(), testInfo.host, L"Host"))
97        return false;
98
99    if (testURL.getPortNum() != testInfo.portNum)
100    {
101        XERCES_STD_QUALIFIER wcout << L"Expected port number: " << testInfo.portNum
102                   << L" but got: " << testURL.getPortNum() << XERCES_STD_QUALIFIER endl;
103        return false;
104    }
105
106    if (!checkAField(testURL.getPath(), testInfo.path, L"Path"))
107        return false;
108
109    if (!checkAField(testURL.getPassword(), testInfo.password, L"Password"))
110        return false;
111
112    if (!checkAField(testURL.getQuery(), testInfo.query, L"Query"))
113        return false;
114
115    if (!checkAField(testURL.getUser(), testInfo.user, L"User"))
116        return false;
117
118    return true;
119}
120
121static bool basicURLTest()
122{
123    static BasicTestEntry testList[] =
124    {
125        {
126            L"file://user:password@host/path1/path2/file.txt?query#fragment"
127            , L"file://user:password@host/path1/path2/file.txt?query#fragment"
128            , XMLURL::File
129            , 0
130            , L"fragment"
131            , L"host"
132            , L"/path1/path2/file.txt"
133            , L"password"
134            , L"query"
135            , L"user"
136        }
137      , {
138            L"file:///path2/file.txt?query#fragment"
139            , L"file:///path2/file.txt?query#fragment"
140            , XMLURL::File
141            , 0
142            , L"fragment"
143            , 0
144            , L"/path2/file.txt"
145            , 0
146            , L"query"
147            , 0
148        }
149      , {
150            L"#fragment"
151            , L"#fragment"
152            , XMLURL::Unknown
153            , 0
154            , L"fragment"
155            , 0
156            , 0
157            , 0
158            , 0
159            , 0
160        }
161      , {
162            L"file://user@host/path1/path2/file.txt#fragment"
163            , L"file://user@host/path1/path2/file.txt#fragment"
164            , XMLURL::File
165            , 0
166            , L"fragment"
167            , L"host"
168            , L"/path1/path2/file.txt"
169            , 0
170            , 0
171            , L"user"
172        }
173      , {
174            L"     file://user@host/path1/path2/file.txt#fragment"
175            , L"file://user@host/path1/path2/file.txt#fragment"
176            , XMLURL::File
177            , 0
178            , L"fragment"
179            , L"host"
180            , L"/path1/path2/file.txt"
181            , 0
182            , 0
183            , L"user"
184        }
185      , {
186            L"http://host:90/path1/path2/file.txt"
187            , L"http://host:90/path1/path2/file.txt"
188            , XMLURL::HTTP
189            , 90
190            , 0
191            , L"host"
192            , L"/path1/path2/file.txt"
193            , 0
194            , 0
195            , 0
196        }
197      , {
198            L"http://host/path1/path2/file.txt"
199            , L"http://host/path1/path2/file.txt"
200            , XMLURL::HTTP
201            , 80
202            , 0
203            , L"host"
204            , L"/path1/path2/file.txt"
205            , 0
206            , 0
207            , 0
208        }
209      , {
210            L"ftp://"
211            , L"ftp://"
212            , XMLURL::FTP
213            , 21
214            , 0
215            , 0
216            , 0
217            , 0
218            , 0
219            , 0
220        }
221      , {
222            L"ftp://user@"
223            , L"ftp://user@"
224            , XMLURL::FTP
225            , 21
226            , 0
227            , 0
228            , 0
229            , 0
230            , 0
231            , L"user"
232        }
233    };
234    const unsigned int testCount = sizeof(testList) / sizeof(testList[0]);
235
236    bool retVal = true;
237
238    //
239    //  Do a run where we construct the URL over and over for each
240    //  test.
241    //
242    unsigned int index;
243    for (index = 0; index < testCount; index++)
244    {
245        // Force full destruction each time
246        {
247            XMLURL testURL(testList[index].orgURL);
248
249            // Call the comparison function
250            if (!checkBasicResult(testURL, testList[index]))
251                retVal = false;
252        }
253    }
254
255    //
256    //  Do a run where we use a single URL object and just reset it over
257    //  and over again.
258    //
259    XMLURL testURL;
260    for (index = 0; index < testCount; index++)
261    {
262        testURL.setURL(testList[index].orgURL);
263
264        // Call the comparison function
265        if (!checkBasicResult(testURL, testList[index]))
266            retVal = false;
267    }
268
269    return retVal;
270}
271
272
273//
274//  This test makes sure that parsing one URL relative to another works
275//  correctly. The tests used here come from one of the internet RFCs on
276//  generic URI syntax. A single base URL is created, then a number of
277//  relative URLs are parsed against it and the results compared to the
278//  expected result.
279//
280static bool relativeURLTest()
281{
282    static struct TestEntry
283    {
284        const XMLCh*    relative;
285        const XMLCh*    result;
286    } testList[] =
287    {
288        { L"g"      , L"http://a/b/c/g" }
289      , { L"./g"    , L"http://a/b/c/g" }
290      , { L"g/"     , L"http://a/b/c/g/" }
291      , { L"/g"     , L"http://a/g" }
292      , { L"?y"     , L"http://a/b/c/?y" }
293      , { L"g?y"    , L"http://a/b/c/g?y" }
294      , { L"#s"     , L"http://a/b/c/d;p#s" }
295      , { L"g#s"    , L"http://a/b/c/g#s" }
296      , { L"g?y#s"  , L"http://a/b/c/g?y#s" }
297      , { L";x"     , L"http://a/b/c/;x" }
298      , { L"g;x"    , L"http://a/b/c/g;x" }
299      , { L"g;x?y#s", L"http://a/b/c/g;x?y#s" }
300      , { L"."      , L"http://a/b/c/" }
301      , { L"./"     , L"http://a/b/c/" }
302      , { L".."     , L"http://a/b/" }
303      , { L"../"    , L"http://a/b/" }
304      , { L"../g"   , L"http://a/b/g" }
305      , { L"../.."  , L"http://a/" }
306      , { L"../../" , L"http://a/" }
307      , { L"../../g", L"http://a/g" }
308    };
309    const unsigned int testCount = sizeof(testList) / sizeof(testList[0]);
310
311    // This is the base URL against which the tests are run
312    XMLURL baseURL(L"http://a/b/c/d;p?q");
313
314    bool retVal = true;
315    for (unsigned int index = 0; index < testCount; index++)
316    {
317        XMLURL testURL(baseURL, testList[index].relative);
318
319        if (XMLString::compareString(testURL.getURLText(), testList[index].result))
320        {
321            XERCES_STD_QUALIFIER wcout  << L"Expected URL: " << testList[index].result
322                        << L" but got: " << testURL.getURLText() << XERCES_STD_QUALIFIER endl;
323            retVal = false;
324        }
325    }
326    return retVal;
327};
328
329
330// ---------------------------------------------------------------------------
331//  Test entry point
332// ---------------------------------------------------------------------------
333bool testURL()
334{
335    XERCES_STD_QUALIFIER wcout  << L"----------------------------------\n"
336                << L"Testing URL class \n"
337                << L"----------------------------------"
338                << XERCES_STD_QUALIFIER endl;
339
340    bool retVal = true;
341    try
342    {
343        // Call other local methods to do specific tests
344        XERCES_STD_QUALIFIER wcout << L"Testing basic URL parsing" << XERCES_STD_QUALIFIER endl;
345        if (!basicURLTest())
346        {
347            XERCES_STD_QUALIFIER wcout << L"Basic URL parsing tests failed" << XERCES_STD_QUALIFIER endl;
348            retVal = false;
349        }
350         else
351        {
352            XERCES_STD_QUALIFIER wcout << L"Basic URL parsing tests passed" << XERCES_STD_QUALIFIER endl;
353        }
354        XERCES_STD_QUALIFIER wcout << XERCES_STD_QUALIFIER endl;
355
356        XERCES_STD_QUALIFIER wcout << L"Testing relative URL parsing" << XERCES_STD_QUALIFIER endl;
357        if (!relativeURLTest())
358        {
359            XERCES_STD_QUALIFIER wcout << L"Relative URL parsing tests failed" << XERCES_STD_QUALIFIER endl;
360            retVal = false;
361        }
362         else
363        {
364            XERCES_STD_QUALIFIER wcout << L"Relative URL parsing tests passed" << XERCES_STD_QUALIFIER endl;
365        }
366        XERCES_STD_QUALIFIER wcout << XERCES_STD_QUALIFIER endl;
367    }
368
369    catch(const XMLException& toCatch)
370    {
371        XERCES_STD_QUALIFIER wcout  << L"  ERROR: Unexpected exception!\n   Msg: "
372                    << toCatch.getMessage() << XERCES_STD_QUALIFIER endl;
373        return false;
374    }
375    return retVal;
376}
Note: See TracBrowser for help on using the repository browser.