QStringList ItemSyncTests::testTags()
{
return QStringList()
<< testTag(1)
<< testTag(2)
<< testTag(3)
<< testTag(4)
<< testTag(5);
}
void
NewResourceBundleTest::TestResourceBundles()
{
UErrorCode status = U_ZERO_ERROR;
loadTestData(status);
if(U_FAILURE(status))
{
dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status)));
return;
}
/* Make sure that users using te_IN for the default locale don't get test failures. */
Locale originalDefault;
if (Locale::getDefault() == Locale("te_IN")) {
Locale::setDefault(Locale("en_US"), status);
}
testTag("only_in_Root", TRUE, FALSE, FALSE);
testTag("only_in_te", FALSE, TRUE, FALSE);
testTag("only_in_te_IN", FALSE, FALSE, TRUE);
testTag("in_Root_te", TRUE, TRUE, FALSE);
testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE);
testTag("in_Root_te_IN", TRUE, FALSE, TRUE);
testTag("in_te_te_IN", FALSE, TRUE, TRUE);
testTag("nonexistent", FALSE, FALSE, FALSE);
logln("Passed: %d\nFailed: %d", pass, fail);
/* Restore the default locale for the other tests. */
Locale::setDefault(originalDefault, status);
}
void EpubEncryptionFileReader::endElementHandler(const char *tag) {
switch (myState) {
case READ_NONE:
case READ_SUCCESS:
break;
case READ_ENCRYPTION:
if (testTag(ZLXMLNamespace::EpubContainer, "encryption", tag)) {
myState = READ_SUCCESS;
}
break;
case READ_ENCRYPTED_DATA:
if (testTag(ZLXMLNamespace::XMLEncryption, "EncryptedData", tag)) {
if (EMBEDDING_ALGORITHM == myAlgorithm) {
myInfos.push_back(new FileEncryptionInfo(
myUri, EncryptionMethod::EMBEDDING, myAlgorithm, publicationId()
));
} else {
std::vector<std::string>::const_iterator it =
std::find(myKnownMethods.begin(), myKnownMethods.end(), EncryptionMethod::MARLIN);
if (it != myKnownMethods.end()) {
myInfos.push_back(new FileEncryptionInfo(
myUri, EncryptionMethod::MARLIN, myAlgorithm, myKeyName
));
}
}
myState = READ_ENCRYPTION;
}
break;
case READ_KEY_INFO:
if (testTag(ZLXMLNamespace::XMLDigitalSignature, "KeyInfo", tag)) {
myState = READ_ENCRYPTED_DATA;
}
break;
case READ_KEY_NAME:
if (testTag(ZLXMLNamespace::XMLDigitalSignature, "KeyName", tag)) {
myState = READ_KEY_INFO;
}
break;
case READ_CIPHER_DATA:
if (testTag(ZLXMLNamespace::XMLEncryption, "CipherData", tag)) {
myState = READ_ENCRYPTED_DATA;
}
break;
}
}
void OEBMetaInfoReader::startElementHandler(const char *tag, const char **attributes) {
const std::string tagString = ZLUnicodeUtil::toLower(tag);
switch (myReadState) {
default:
break;
case READ_NONE:
if (testTag(ZLXMLNamespace::OpenPackagingFormat, METADATA, tagString) ||
DC_METADATA == tagString) {
myReadState = READ_METADATA;
}
break;
case READ_METADATA:
if (testDCTag("title", tagString)) {
myReadState = READ_TITLE;
} else if (testDCTag("creator", tagString)) {
const char *role = attributeValue(attributes, "role");
if (role == 0) {
myReadState = READ_AUTHOR2;
} else if (AUTHOR_ROLE == role) {
myReadState = READ_AUTHOR;
}
} else if (testDCTag("subject", tagString)) {
myReadState = READ_SUBJECT;
} else if (testDCTag("language", tagString)) {
myReadState = READ_LANGUAGE;
} else if (testDCTag("identifier", tagString)) {
myReadState = READ_IDENTIFIER;
static const FullNamePredicate schemePredicate(ZLXMLNamespace::OpenPackagingFormat, "scheme");
const char *scheme = attributeValue(attributes, schemePredicate);
myIdentifierScheme = scheme != 0 ? scheme : "EPUB-NOSCHEME";
} else if (testTag(ZLXMLNamespace::OpenPackagingFormat, META, tagString)) {
const char *name = attributeValue(attributes, "name");
const char *content = attributeValue(attributes, "content");
if (name != 0 && content != 0) {
std::string sName = name;
if (sName == "calibre:series" || isNSName(sName, "series", ZLXMLNamespace::CalibreMetadata)) {
myBook.setSeries(content, myBook.indexInSeries());
} else if (sName == "calibre:series_index" || isNSName(sName, "series_index", ZLXMLNamespace::CalibreMetadata)) {
myBook.setSeries(myBook.seriesTitle(), content);
}
}
}
break;
}
}
void EpubEncryptionFileReader::startElementHandler(const char *tag, const char **attributes) {
switch (myState) {
case READ_SUCCESS:
break;
case READ_NONE:
if (testTag(ZLXMLNamespace::EpubContainer, "encryption", tag)) {
myState = READ_ENCRYPTION;
} else {
interrupt();
}
break;
case READ_ENCRYPTION:
if (testTag(ZLXMLNamespace::XMLEncryption, "EncryptedData", tag)) {
myState = READ_ENCRYPTED_DATA;
} else {
interrupt();
}
break;
case READ_ENCRYPTED_DATA:
if (testTag(ZLXMLNamespace::XMLEncryption, "EncryptionMethod", tag)) {
const char *algorithm = attributeValue(attributes, "Algorithm");
if (algorithm != 0) {
myAlgorithm = algorithm;
} else {
interrupt();
}
} else if (testTag(ZLXMLNamespace::XMLDigitalSignature, "KeyInfo", tag)) {
myState = READ_KEY_INFO;
} else if (testTag(ZLXMLNamespace::XMLEncryption, "CipherData", tag)) {
myState = READ_CIPHER_DATA;
} else {
interrupt();
}
break;
case READ_KEY_INFO:
if (testTag(ZLXMLNamespace::XMLDigitalSignature, "KeyName", tag)) {
myState = READ_KEY_NAME;
myKeyName.clear();
} else {
interrupt();
}
break;
case READ_KEY_NAME:
interrupt();
break;
case READ_CIPHER_DATA:
if (testTag(ZLXMLNamespace::XMLEncryption, "CipherReference", tag)) {
const char *uri = attributeValue(attributes, "URI");
if (uri != 0) {
myUri = uri;
} else {
interrupt();
}
} else {
interrupt();
}
break;
}
}
void OEBMetaInfoReader::endElementHandler(const char *tag) {
const std::string tagString = ZLUnicodeUtil::toLower(tag);
ZLUnicodeUtil::utf8Trim(myBuffer);
switch (myReadState) {
case READ_NONE:
return;
case READ_METADATA:
if (testTag(ZLXMLNamespace::OpenPackagingFormat, METADATA, tagString) ||
DC_METADATA == tagString) {
interrupt();
myReadState = READ_NONE;
return;
}
break;
case READ_AUTHOR:
if (!myBuffer.empty()) {
myAuthorList.push_back(myBuffer);
}
break;
case READ_AUTHOR2:
if (!myBuffer.empty()) {
myAuthorList2.push_back(myBuffer);
}
break;
case READ_SUBJECT:
if (!myBuffer.empty()) {
myBook.addTag(myBuffer);
}
break;
case READ_TITLE:
if (!myBuffer.empty()) {
myBook.setTitle(myBuffer);
}
break;
case READ_LANGUAGE:
if (!myBuffer.empty()) {
int index = myBuffer.find('-');
if (index >= 0) {
myBuffer = myBuffer.substr(0, index);
}
index = myBuffer.find('_');
if (index >= 0) {
myBuffer = myBuffer.substr(0, index);
}
myBook.setLanguage(myBuffer);
}
break;
case READ_IDENTIFIER:
if (!myBuffer.empty()) {
myBook.addUid(myIdentifierScheme, myBuffer);
}
break;
}
myBuffer.erase();
myReadState = READ_METADATA;
}
void TestResourceBundles()
{
UErrorCode status = U_ZERO_ERROR;
loadTestData(&status);
if(U_FAILURE(status)) {
log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
return;
}
testTag("only_in_Root", TRUE, FALSE, FALSE);
testTag("in_Root_te", TRUE, TRUE, FALSE);
testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE);
testTag("in_Root_te_IN", TRUE, FALSE, TRUE);
testTag("only_in_te", FALSE, TRUE, FALSE);
testTag("only_in_te_IN", FALSE, FALSE, TRUE);
testTag("in_te_te_IN", FALSE, TRUE, TRUE);
testTag("nonexistent", FALSE, FALSE, FALSE);
log_verbose("Passed:= %d Failed= %d \n", pass, fail);
}
void OEBUidReader::startElementHandler(const char *tag, const char **attributes) {
const std::string tagString = ZLUnicodeUtil::toLower(tag);
switch (myReadState) {
default:
break;
case READ_NONE:
if (testTag(ZLXMLNamespace::OpenPackagingFormat, METADATA, tagString) ||
DC_METADATA == tagString) {
myReadState = READ_METADATA;
}
break;
case READ_METADATA:
if (testDCTag("identifier", tagString)) {
myReadState = READ_IDENTIFIER;
static const FullNamePredicate schemePredicate(ZLXMLNamespace::OpenPackagingFormat, "scheme");
const char *scheme = attributeValue(attributes, schemePredicate);
myIdentifierScheme = scheme != 0 ? scheme : "EPUB-NOSCHEME";
}
break;
}
}
void OEBUidReader::endElementHandler(const char *tag) {
const std::string tagString = ZLUnicodeUtil::toLower(tag);
ZLUnicodeUtil::utf8Trim(myBuffer);
switch (myReadState) {
case READ_NONE:
break;
case READ_METADATA:
if (testTag(ZLXMLNamespace::OpenPackagingFormat, METADATA, tagString) ||
DC_METADATA == tagString) {
interrupt();
myReadState = READ_NONE;
return;
}
break;
case READ_IDENTIFIER:
if (!myBuffer.empty()) {
myBook.addUid(myIdentifierScheme, myBuffer);
}
myReadState = READ_METADATA;
break;
}
myBuffer.erase();
}
bool OEBMetaInfoReader::testDCTag(const std::string &name, const std::string &tag) const {
return
testTag(ZLXMLNamespace::DublinCore, name, tag) ||
testTag(ZLXMLNamespace::DublinCoreLegacy, name, tag);
}
void EpubRightsFileReader::startElementHandler(const char *tag, const char**) {
if (testTag(ZLXMLNamespace::MarlinEpub, "Marlin", tag)) {
myMethod = EncryptionMethod::MARLIN;
}
interrupt();
}
bool OEBBookReader::isOPFTag(const std::string &expected, const std::string &tag) const {
return expected == tag || testTag(ZLXMLNamespace::OpenPackagingFormat, expected, tag);
}
