--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/xml/xmlexpatparser/test/rtest/tsrc/t_xmlparser.cpp Thu Dec 17 09:29:21 2009 +0200
@@ -0,0 +1,919 @@
+// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32test.h>
+#include <ecom/ecom.h>
+
+#include <xml/matchdata.h>
+#include <xml/parserfeature.h>
+#include <xml/xmlparsererrors.h>
+
+#include "t_xmlparser.h"
+#include "unzip.h"
+
+using namespace Xml;
+
+RTest test(_L("XML parser tests")); // must be called 'test', as the e32test macros rely on this.
+
+// Installed via bld.inf test exports
+_LIT(KBigTestFile, "c:\\system\\data\\xml\\xml\\networking.xml");
+_LIT(KRefFilename, "c:\\system\\data\\xml\\xml\\ref-networking.xml");
+_LIT(KSimpleTestFile, "c:\\system\\data\\xml\\xml\\simple.xml");
+_LIT(KInvalidTestFile, "c:\\system\\data\\xml\\xml\\invalid.xml");
+_LIT(KNamespaceTestFile, "c:\\system\\data\\xml\\xml\\namespace.xml");
+_LIT(KEntityTestFile, "c:\\system\\data\\xml\\xml\\entity.xml");
+_LIT(KCapsTestFile, "c:\\system\\data\\xml\\xml\\caps.xml");
+_LIT(KEncodingTestFile, "c:\\system\\data\\xml\\xml\\doc_jp_utf.xml");
+_LIT(KEncodingRefFile, "c:\\system\\data\\xml\\xml\\ref_doc_jp_utf.xml");
+
+_LIT(KZipTestFile, "z:\\system\\data\\xml\\xml.zip");
+_LIT(KXmlTestDir, "c:\\system\\data\\xml");
+
+_LIT8(KIncompleteData, "<DIDL-Lite xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:upnp=\"urn:schemas-upnp-org:metadata-1-0/upnp/\" xmlns=\"urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/\"><container id=\"1\" parentID=\"0\" child ");
+
+_LIT8(KParserDataType, "text/xml");
+_LIT8(KParserDataType2, "text/wbxml");
+_LIT8(KParserDataType3, "text/unique");
+_LIT8(KParserDataType4, "text/same");
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3734
+@SYMTestCaseDesc Parsing an xml document.
+@SYMTestPriority Medium
+@SYMTestActions Takes networking.xml, parses it and reconstitutes it as XML. A comparison
+ between the output in Epocwind.out and networking.xml can be used to show
+ that the parser is doing what it should.
+ The test has now been automated to diff the output with ref-networking.xml.
+@SYMTestExpectedResults The document is parsed without any issues.
+@SYMPREQ PREQ230
+*/
+LOCAL_C void BasicParsingTestL()
+ {
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ RFile result;
+ TFileName filename;
+ User::LeaveIfError(result.Temp(fs, _L("C:\\"), filename, EFileWrite));
+ CleanupClosePushL(result);
+
+ TRebuildingContentHandler contentHandler(result);
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ ParseL(*parser, fs, KBigTestFile());
+ test(contentHandler.iError==KErrNone);
+
+ CleanupStack::PopAndDestroy(2);
+
+ RFile ref;
+ User::LeaveIfError(ref.Open(fs, KRefFilename, EFileRead));
+ CleanupClosePushL(ref);
+ User::LeaveIfError(result.Open(fs, filename, EFileRead));
+ CleanupClosePushL(result);
+
+ TInt resultSize;
+ User::LeaveIfError(result.Size(resultSize));
+ TInt refSize;
+ User::LeaveIfError(ref.Size(refSize));
+ test(resultSize==refSize);
+
+ TBuf8<256> refBuf;
+ TBuf8<256> resultBuf;
+
+ while(ref.Read(refBuf)==KErrNone && result.Read(resultBuf)==KErrNone && refBuf.Length()>0)
+ test(refBuf==resultBuf);
+
+ test(refBuf.Length()==0 && resultBuf.Length()==0);
+
+ CleanupStack::PopAndDestroy(2);
+ fs.Delete(filename);
+ CleanupStack::PopAndDestroy(&fs);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-1578
+@SYMTestCaseDesc SS31 Symbian XML Framework - Symbian SAX Plugin is not returned by default.
+@SYMTestPriority High
+@SYMTestActions Create CParser and parse test file. Compare number of elements in output
+ to determine which parser is selected. Create CParser and parse test file
+ with CMatchData API with default supplied parameters. Test for selected parser.
+@SYMTestExpectedResults Test should not fail. Symbian parser is expected to be selected.
+@SYMDEF INC073582
+*/
+LOCAL_C void INC073582L()
+ {
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ TSimpleContentHandler* handler = new (ELeave) TSimpleContentHandler();
+ CleanupStack::PushL(handler);
+
+ RFile handle;
+ User::LeaveIfError(handle.Open(fs, KSimpleTestFile, EFileShareReadersOnly));
+ CleanupClosePushL(handle);
+
+ // Test default behaviour of text/xml parser (multiple parsers return Symbian)
+
+ CParser* parser = CParser::NewLC(KParserDataType, *handler);
+
+ ParseL(*parser, handle);
+ //Expected: handler->iNumElements == 6
+ // Production, Symbian parser.
+ test(handler->iNumElements==6);
+
+ CleanupStack::PopAndDestroy(parser);
+
+ // Test default behaviour with CMatchData supplied version of CParser
+
+ CMatchData *matchData = CMatchData::NewLC();
+
+ matchData->SetMimeTypeL(KParserDataType);
+ matchData->SetVariantL(_L8(""));
+
+ parser = CParser::NewLC(*matchData, *handler);
+
+ ParseL(*parser, handle);
+ //Expected: handler->iNumElements == 6
+ // Production, Symbian parser.
+ test(handler->iNumElements==6);
+
+ CleanupStack::PopAndDestroy(parser);
+ CleanupStack::PopAndDestroy(matchData);
+
+ // Test default behaviour of text/wbxml parser (multiple parsers return Symbian-first)
+
+ parser = CParser::NewLC(KParserDataType2, *handler);
+
+ ParseL(*parser, handle);
+ //Expected: handler->iNumElements == 6
+ // Production, Symbian parser.
+ test(handler->iNumElements==6);
+
+ CleanupStack::PopAndDestroy(parser);
+
+ // Test default behaviour of text/unique parser (single parser non-Symbian)
+
+ parser = CParser::NewLC(KParserDataType3, *handler);
+
+ ParseL(*parser, handle);
+ //Expected: handler->iNumElements == 1
+ // Test parser1.
+ test(handler->iNumElements==1);
+
+ CleanupStack::PopAndDestroy(parser);
+
+ // Test default behaviour of text/same parser (multiple parser non-Symbian, return lowest uid)
+
+ parser = CParser::NewLC(KParserDataType4, *handler);
+
+ ParseL(*parser, handle);
+ //Expected: handler->iNumElements == 1
+ // Test parser1.
+ test(handler->iNumElements==1);
+
+ CleanupStack::PopAndDestroy(parser);
+
+ CleanupStack::PopAndDestroy(&handle);
+ CleanupStack::PopAndDestroy(handler);
+ CleanupStack::PopAndDestroy(&fs);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3735
+@SYMTestCaseDesc Parsing a document larger than the Expat internal buffer.
+@SYMTestPriority Medium
+@SYMTestActions Checks that a descriptor larger than Expats internal buffer can be parsed successfully.
+@SYMTestExpectedResults The xml document is parsed correctly.
+@SYMDEF DEF056122
+*/
+LOCAL_C void DEF056122L()
+ {
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ RFile result;
+ TFileName filename;
+ User::LeaveIfError(result.Temp(fs, _L("C:\\"), filename, EFileWrite));
+ CleanupClosePushL(result);
+
+ TRebuildingContentHandler contentHandler(result);
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+
+ // Read the test file into a descriptor
+
+ RFile file;
+
+ User::LeaveIfError(file.Open (fs, KBigTestFile(), EFileRead|EFileShareReadersOnly));
+ CleanupClosePushL (file);
+
+ TInt size = 0;
+ file.Size (size);
+
+ HBufC8* rawdocheap = HBufC8::NewLC (size);
+ TPtr8 rawdoc(rawdocheap->Des ());
+
+ User::LeaveIfError (file.Read (rawdoc, size));
+
+ // Parse the descriptor
+
+ ParseL(*parser, rawdoc);
+ test(contentHandler.iError==KErrNone);
+
+ CleanupStack::PopAndDestroy(4);
+
+ // Test everything worked
+
+ RFile ref;
+ User::LeaveIfError(ref.Open(fs, KRefFilename, EFileRead));
+ CleanupClosePushL(ref);
+ User::LeaveIfError(result.Open(fs, filename, EFileRead));
+ CleanupClosePushL(result);
+
+ TInt resultSize;
+ User::LeaveIfError(result.Size(resultSize));
+ TInt refSize;
+ User::LeaveIfError(ref.Size(refSize));
+ test(resultSize==refSize);
+
+ TBuf8<256> refBuf;
+ TBuf8<256> resultBuf;
+
+ while(ref.Read(refBuf)==KErrNone && result.Read(resultBuf)==KErrNone && refBuf.Length()>0)
+ test(refBuf==resultBuf);
+
+ test(refBuf.Length()==0 && resultBuf.Length()==0);
+
+ CleanupStack::PopAndDestroy(2);
+ fs.Delete(filename);
+ CleanupStack::PopAndDestroy(&fs);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-1598
+@SYMTestCaseDesc Tests to make sure XML parser does not crash when parsing a message that is not complete.
+@SYMTestPriority Medium
+@SYMTestActions Parses the message that is not complete.
+@SYMTestExpectedResults Test must not fail.
+@SYMDEF INC073797
+*/
+LOCAL_C void INC073797()
+ {
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ RFile result;
+ TFileName filename;
+ User::LeaveIfError(result.Temp(fs, _L("C:\\"), filename, EFileWrite));
+ CleanupClosePushL(result);
+
+ TRebuildingContentHandler contentHandler(result);
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ parser->ParseL(KIncompleteData());
+ test(contentHandler.iError==KErrNone);
+
+ CleanupStack::PopAndDestroy(2);
+
+ fs.Delete(filename);
+ CleanupStack::PopAndDestroy(&fs);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3736
+@SYMTestCaseDesc Parsing an xml file with extended character..
+@SYMTestPriority Medium
+@SYMTestActions Checks that the parser can deal with extended characters - locales outside of ascii.
+ Parses doc_jp_utf.xml, reconstitutes it as xml, and compares with ref_doc_jp_utf.xml.
+@SYMTestExpectedResults The reconstructed document is the same as the original document.
+@SYMDEF DEF051379
+*/
+LOCAL_C void DEF051379L()
+ {
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ TInt pos = 0;
+
+ //open a temporary results file
+ RFile result;
+ TFileName filename;
+ User::LeaveIfError(result.Temp(fs, _L("C:\\"), filename, EFileWrite));
+ CleanupClosePushL(result);
+
+ //reconstitutes the xml from parser callbacks
+ TRebuildingContentHandler contentHandler(result);
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ //parse the file
+ ParseL(*parser, fs, KEncodingTestFile());
+ test(contentHandler.iError==KErrNone);
+
+ //open the reference file, and compare with results file
+ RFile ref;
+ User::LeaveIfError(ref.Open(fs, KEncodingRefFile, EFileRead));
+ CleanupClosePushL(ref);
+
+ User::LeaveIfError(result.Seek(ESeekStart,pos));
+
+ TInt resultSize;
+ User::LeaveIfError(result.Size(resultSize));
+ TInt refSize;
+ User::LeaveIfError(ref.Size(refSize));
+ test(resultSize==refSize);
+
+ TBuf8<256> refBuf;
+ TBuf8<256> resultBuf;
+
+ while(ref.Read(refBuf)==KErrNone && result.Read(resultBuf)==KErrNone && refBuf.Length()>0)
+ test(refBuf==resultBuf);
+
+ //check that RFile::Read has read the entire contents of each file,
+ //so that length (from cursor position to end of file) == 0
+ test(refBuf.Length()==0 && resultBuf.Length()==0);
+
+
+ CleanupStack::PopAndDestroy(&ref);
+ CleanupStack::PopAndDestroy(parser);
+ CleanupStack::PopAndDestroy(&result);
+ fs.Delete(filename);
+ CleanupStack::PopAndDestroy(&fs);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3737
+@SYMTestCaseDesc Parsing multiple documents in sequence.
+@SYMTestPriority Medium
+@SYMTestActions Checks that the parser can be reset after parsing one document and used to parse another.
+@SYMTestExpectedResults The contenthandler is able to deal with the parsing of 2 xml documents in sequence.
+@SYMPREQ PREQ230
+*/
+LOCAL_C void ResetTestL()
+ {
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ TSimpleContentHandler contentHandler;
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ ParseL(*parser, fs, KSimpleTestFile());
+
+ test(contentHandler.iNumElements==6);
+ test(contentHandler.iError==KErrNone);
+
+ ParseL(*parser, fs, KBigTestFile());
+
+ test(contentHandler.iNumElements==832);
+ test(contentHandler.iError==KErrNone);
+
+ CleanupStack::PopAndDestroy(2);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3738
+@SYMTestCaseDesc Parser copes with leaving content handler.
+@SYMTestPriority Medium
+@SYMTestActions Checks that the parser copes with a leave from a content handler callback.
+@SYMTestExpectedResults Tests pass.
+@SYMPREQ PREQ230
+*/
+LOCAL_C void CallbackLeaveTestL()
+ {
+ TSimpleContentHandler contentHandler;
+ contentHandler.iLeaveOnStartElement = ETrue;
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ TRAPD(err, ParseL(*parser, fs, KSimpleTestFile()));
+
+ User::LeaveIfError(err); // For OOM testing
+
+ test(contentHandler.iNumElements==1);
+ test(err==TSimpleContentHandler::KExpectedLeaveCode);
+
+ contentHandler.iLeaveOnStartElement = EFalse;
+ ParseL(*parser, fs, KSimpleTestFile());
+ test(contentHandler.iNumElements==6);
+
+ CleanupStack::PopAndDestroy(2);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3739
+@SYMTestCaseDesc Well-formedness errors are propagated.
+@SYMTestPriority Medium
+@SYMTestActions Checks that well-formedness errors generated by the parser are propagated.
+@SYMTestExpectedResults content handler reports the error.
+@SYMPREQ PREQ230
+*/
+LOCAL_C void InvalidXmlTestL()
+ {
+ TSimpleContentHandler contentHandler;
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ ParseL(*parser, fs, KInvalidTestFile());
+ if(contentHandler.iError!=EXmlInvalidToken)
+ User::Leave(contentHandler.iError); // For OOM testing
+
+ CleanupStack::PopAndDestroy(2);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3740
+@SYMTestCaseDesc Reporting namespace uri's and prefixes.
+@SYMTestPriority Medium
+@SYMTestActions Checks that namespace uri's and prefixes are correctly reported.
+@SYMTestExpectedResults content handler has no errors.
+@SYMPREQ PREQ230
+*/
+LOCAL_C void NamespaceTestL()
+ {
+ _LIT8(KDefaultUri, "http://www.symbian.com");
+ _LIT8(KElementPrefix, "elprefix");
+ _LIT8(KElementUri, "http://element.uri");
+ _LIT8(KAttributePrefix, "attprefix");
+ _LIT8(KAttributeUri, "http://attribute.uri");
+
+ TNamespaceContentHandler contentHandler(KDefaultUri, KElementPrefix, KElementUri, KAttributePrefix, KAttributeUri);
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ User::LeaveIfError(parser->EnableFeature(EReportNamespaceMapping));
+
+ ParseL(*parser, fs, KNamespaceTestFile());
+ User::LeaveIfError(contentHandler.iError); // For OOM testing
+
+ test(contentHandler.iError==KErrNone);
+
+ CleanupStack::PopAndDestroy(2);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3741
+@SYMTestCaseDesc Converting character set.
+@SYMTestPriority Medium
+@SYMTestActions Checks that skipped entities are reported.
+@SYMTestExpectedResults The expected conversion result and the actual conversion result match.
+@SYMPREQ PREQ230
+*/
+LOCAL_C void SkippedEntityTestL()
+ {
+ TSimpleContentHandler contentHandler;
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ ParseL(*parser, fs, KEntityTestFile());
+ User::LeaveIfError(contentHandler.iError); // For OOM testing
+
+ test(contentHandler.iError==KErrNone);
+ test(contentHandler.iNumSkippedEntities==2);
+
+ CleanupStack::PopAndDestroy(2);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3742
+@SYMTestCaseDesc Testing the Features functions of CParser, to make sure they work correctly.
+@SYMTestPriority Medium
+@SYMTestActions Create the parser object and enable and disable features, testing if they are allowed or not.
+@SYMTestExpectedResults Enabling and Disabling features return the expected result.
+@SYMCR CR0000
+*/
+LOCAL_C void ParserFeatureTestL()
+ {
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ TCapsContentHandler contentHandler;
+
+ CParser* parser = CParser::NewLC(KParserDataType, contentHandler);
+
+ // Use a non-existing feature
+ test(parser->EnableFeature(0xFFFFFFFF) == KErrNotSupported);
+ test(parser->DisableFeature(0xFFFFFFFF) == KErrNotSupported);
+
+ // Enable defined but unsupported features
+ test(parser->EnableFeature(EErrorOnUnrecognisedTags) == KErrNotSupported);
+ test(parser->EnableFeature(EReportUnrecognisedTags) == KErrNotSupported);
+ test(parser->EnableFeature(ESendFullContentInOneChunk) == KErrNotSupported);
+ test(parser->EnableFeature(ERawContent) == KErrNotSupported);
+
+ // Enable supported features
+ test(parser->EnableFeature(EReportNamespaces) == KErrNone);
+ test(parser->EnableFeature(EReportNamespacePrefixes) == KErrNone);
+ test(parser->EnableFeature(EReportNamespaceMapping) == KErrNone);
+ test(parser->EnableFeature(EConvertTagsToLowerCase) == KErrNone);
+
+ // Disable mandatory features
+ test(parser->DisableFeature(EReportNamespacePrefixes)==KErrNotSupported);
+ test(parser->DisableFeature(EReportNamespaces)==KErrNotSupported);
+
+ // Disable optional features
+ test(parser->DisableFeature(EReportNamespaceMapping) == KErrNone);
+ test(parser->DisableFeature(EConvertTagsToLowerCase) == KErrNone);
+
+ // Re-enable optional features needed for test
+ test(parser->EnableFeature(EConvertTagsToLowerCase | EReportNamespaceMapping)
+ == KErrNone);
+
+ ParseL(*parser, fs, KCapsTestFile());
+
+ test(contentHandler.iNumElements == 1);
+ test(contentHandler.iNumPrefixMappings == 2);
+ test(contentHandler.iNumPrefixUnmappings == 2);
+ test(contentHandler.iError == KErrNone);
+
+ TSimpleContentHandler contentHandler2;
+
+ CParser* parser2 = CParser::NewLC(KParserDataType, contentHandler2);
+
+ parser2->EnableFeature(EReportNamespaceMapping);
+
+ ParseL(*parser2, fs, KNamespaceTestFile());
+
+ test(contentHandler2.iNumElements == 5);
+ test(contentHandler2.iNumPrefixMappings == 3);
+ test(contentHandler2.iNumPrefixUnmappings == 3);
+ test(contentHandler2.iError == KErrNone);
+
+ User::LeaveIfError(parser2->DisableFeature(EReportNamespaceMapping));
+ test(!parser2->IsFeatureEnabled(EReportNamespaceMapping));
+
+ ParseL(*parser2, fs, KNamespaceTestFile());
+
+ test(contentHandler2.iNumElements == 5);
+ test(contentHandler2.iNumPrefixMappings == 0);
+ test(contentHandler2.iNumPrefixUnmappings == 0);
+ test(contentHandler2.iError == KErrNone);
+
+ CleanupStack::PopAndDestroy(3);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3745
+@SYMTestCaseDesc Checks that two parsers can co-exist without interfering with each other.
+@SYMTestPriority Medium
+@SYMTestActions Creates 2 content handlers and parsers. Each parser parses a document and checks for errors.
+@SYMTestExpectedResults The parsers should not affect each other and no errors should be produced.
+@SYMPREQ PREQ230
+*/
+LOCAL_C void TwoParserTestL()
+ {
+ TSimpleContentHandler contentHandler1, contentHandler2;
+
+ CParser* parser1 = CParser::NewLC(KParserDataType, contentHandler1);
+
+ CParser* parser2 = CParser::NewLC(KParserDataType, contentHandler2);
+
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ // Parse some of the big test file
+ ParseL(*parser2, fs, KBigTestFile());
+
+ // Check we've read what we expect
+ test(contentHandler1.iNumElements==0);
+ test(contentHandler1.iError==KErrNone);
+
+ test(contentHandler2.iNumElements==832);
+ test(contentHandler2.iError==KErrNone);
+
+ ParseL(*parser1, fs, KSimpleTestFile());
+
+ test(contentHandler1.iNumElements==6);
+ test(contentHandler1.iError==KErrNone);
+
+ // Stats for big test file shouldn't have changed as RunL was never called
+ test(contentHandler2.iNumElements==832);
+ test(contentHandler2.iError==KErrNone);
+
+ CleanupStack::PopAndDestroy(&fs);
+
+ CleanupStack::PopAndDestroy(2);
+ }
+
+
+// ---------------------------------------------------
+
+
+struct TEndHandler : public MContentHandler
+ {
+ // From MContentHandler
+ void OnStartDocumentL(const RDocumentParameters& , TInt ) {};
+ void OnEndDocumentL(TInt) {};
+ void OnStartElementL(const RTagInfo& , const RAttributeArray& , TInt ) {};
+ void OnEndElementL(const RTagInfo& aElement, TInt aErrorCode)
+ {
+ User::LeaveIfError(aErrorCode);
+
+ const TDesC8& localPart8 = aElement.LocalName().DesC();
+ const TDesC8& prefix8 = aElement.Prefix().DesC();
+
+ iOut.Append(_L8("</"));
+
+ if(prefix8.Length())
+ {
+ iOut.Append(prefix8);
+ iOut.Append(_L8(":"));
+ }
+ iOut.Append(localPart8);
+ iOut.Append(_L8(">"));
+ };
+ void OnContentL(const TDesC8& , TInt ) {};
+ void OnStartPrefixMappingL(const RString& , const RString& , TInt ) {};
+ void OnEndPrefixMappingL(const RString& , TInt ) {};
+ void OnIgnorableWhiteSpaceL(const TDesC8& , TInt ) {};
+ void OnSkippedEntityL(const RString& , TInt ) {};
+ void OnProcessingInstructionL(const TDesC8& , const TDesC8& , TInt ) {};
+ void OnExtensionL(const RString& , TInt , TInt ) {};
+ void OnError(TInt aErrorCode) { iError = aErrorCode; };
+ TAny* GetExtendedInterface(const TInt32 ) {return 0;};
+
+ TBuf8<0x100> iOut;
+ TInt iError;
+ };
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3743
+@SYMTestCaseDesc Testing the Expat parser.
+@SYMTestPriority Medium
+@SYMTestActions Creating a simple content handler and parser. Parsing strings and checking the return error code what is expected.
+@SYMTestExpectedResults The results returned by the content handler should be those that are expected.
+@SYMCR CR0000
+*/
+LOCAL_C void ExpatTestL()
+ {
+ TSimpleContentHandler handler;
+
+ CParser* parser = CParser::NewLC(KParserDataType, handler);
+
+ // Here the string is truncated because of the NULL.
+ ParseL(*parser, _L8("<doc>\0</doc>"));
+ test(handler.iError==EXmlNoElements);
+
+ handler.iError = KErrNone;
+ ParseL(*parser, _L8("<doc></dic>"));
+ test(handler.iError==EXmlTagMismatch);
+
+ handler.iError = KErrNone;
+ ParseL(*parser, _L8("\n<?xml version='1.0'?>\n<a/>"));
+ test(handler.iError==EXmlMisplacedPi);
+
+ handler.iError = KErrNone;
+ ParseL(*parser, _L8("<?xml version=\"1.0\" encoding=\"UTF-38x\"?>\n\r<doc></doc>"));
+ test(handler.iError==EXmlUnknownEncoding);
+
+ handler.iError = KErrNone;
+ ParseL(*parser, _L8("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\r<doc></doc>"));
+ test(handler.iError==KErrNone);
+
+ handler.iError = KErrNone;
+ ParseL(*parser, _L8("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\r<doc>hello</doc>"));
+ test(handler.iError==KErrNone);
+
+ handler.iError = KErrNone;
+ ParseL(*parser, _L8("<?xml version=\"1.0\" encoding=\"\"?>\n\r<doc></doc>"));
+ test(handler.iError==EXmlSyntax);
+
+ handler.iError = KErrNone;
+ ParseL(*parser, _L8("<?xml version=\"1.0\"?>\n\r<doc></doc>"));
+ test(handler.iError==KErrNone);
+
+ TEndHandler end;
+ end.iError=KErrNone;
+ CleanupStack::PopAndDestroy(parser);
+ parser = CParser::NewLC(KParserDataType, end);
+
+ ParseL(*parser, _L8("<a><b><c/></b><d><e/></d></a>"));
+ test(end.iError==KErrNone);
+ test(end.iOut==_L8("</c></b></e></d></a>"));
+
+ CleanupStack::PopAndDestroy(parser);
+ }
+
+
+// ---------------------------------------------------
+
+
+/**
+@SYMTestCaseID SYSLIB-XML-CT-3744
+@SYMTestCaseDesc Function to convert a test into an OOM test.
+@SYMTestPriority Medium
+@SYMTestActions Creates a low memory situation and runs the set of tests to make sure the component(s) works in such conditions.
+@SYMTestExpectedResults Tests continue to pass, even in low memory conditions.
+@SYMPREQ PREQ230
+*/
+LOCAL_C void OomTest(void (*testFuncL)())
+ {
+ TInt error;
+ TInt count = 0;
+
+ do
+ {
+ User::__DbgSetAllocFail(RHeap::EUser, RHeap::EFailNext, ++count);
+ User::__DbgMarkStart(RHeap::EUser);
+ TRAP(error, (testFuncL)());
+ User::__DbgMarkEnd(RHeap::EUser, 0);
+ } while(error == KErrNoMemory);
+
+ _LIT(KTestFailed, "Out of memory test failure on iteration %d\n");
+ __ASSERT_ALWAYS(error==KErrNone, test.Panic(error, KTestFailed, count));
+
+ User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 1);
+ }
+
+
+// ---------------------------------------------------
+
+
+// RunTestsL
+// MainL
+// E32Main
+//
+// Top-level functions
+
+LOCAL_C void RunTestsL()
+ {
+ test.Title();
+
+ test.Start(_L("Unziping test xml files"));
+
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ CUnzip* unzip = CUnzip::NewLC(fs, KZipTestFile);
+ unzip->ExtractL(KXmlTestDir);
+ CleanupStack::PopAndDestroy(unzip);
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3734 Basic XML parsing test "));
+ BasicParsingTestL();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3735 DEF056122 descriptors greater than 2048 (Expat internal buffer size) "));
+ DEF056122L();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3736 DEF051379 parsing encoded characters "));
+ DEF051379L();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-1598 INC073797: Stack crashes sometimes in XML parsing in 3.0 platform "));
+ INC073797();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3737 Reset mechanism "));
+ ResetTestL();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3738 Leave from callback "));
+ CallbackLeaveTestL();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3739 Invalid XML handling "));
+ InvalidXmlTestL();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3740 Namespace testing "));
+ NamespaceTestL();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3741 Skipped entity test "));
+ SkippedEntityTestL();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3742 Parser features test "));
+ ParserFeatureTestL();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-1578 INC073582: SS31 Symbian XML Framework - Symbian SAX Plugin is not returned by default "));
+ INC073582L();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3743 "));
+ ExpatTestL();
+
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3744 Out-of-Memory testing "));
+ OomTest(CallbackLeaveTestL);
+ OomTest(InvalidXmlTestL);
+ OomTest(NamespaceTestL);
+ OomTest(SkippedEntityTestL);
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-XML-CT-3745 Two-parser test "));
+ TwoParserTestL();
+
+
+ test.Next(_L("Finished."));
+
+ test.End();
+
+ test.Close();
+
+ CleanupStack::PopAndDestroy(&fs);
+
+ REComSession::FinalClose();
+ }
+
+
+
+
+LOCAL_C void Main()
+ {
+ TRAPD(err, RunTestsL());
+ if (err != KErrNone)
+ User::Panic(_L("Testing failed: "), err);
+ }
+
+TInt E32Main()
+ {
+ __UHEAP_MARK;
+ CTrapCleanup* cleanup=CTrapCleanup::New();
+ if(!cleanup)
+ return KErrNoMemory;
+
+ Main();
+
+ delete cleanup;
+ __UHEAP_MARKEND;
+
+ return 0;
+ }