void TestLanguageFiles::languageSchemeValidationTest()
{
QUrl languageFile = QUrl::fromLocalFile("schemes/language.xsd");
QXmlSchema languageSchema;
QVERIFY(languageSchema.load(languageFile));
QVERIFY(languageSchema.isValid());
}
Object* loadScene(const string& strFileName)
{
qDebug() << "Loading scene from file" << QString::fromStdString(strFileName);
QFile schemaFile(":/Schema/Schema/schema.xsd");
QXmlSchema schema;
WispMessageHandler handler;
schema.setMessageHandler(&handler);
if (!schemaFile.open(QIODevice::ReadOnly))
throw WispException(formatString("Unable to open the XML schema!"));
if (!schema.load(schemaFile.readAll()))
throw WispException(formatString("Unable to parse the XML schema!"));
QXmlSchemaValidator validator(schema);
QFile file(QString::fromStdString(strFileName));
if (!file.open(QIODevice::ReadOnly))
throw WispException(formatString("Unable to open the file \"%s\"", strFileName.c_str()));
if (!validator.validate(&file))
throw WispException(formatString("Unable to validate the file \"%s\"", strFileName.c_str()));
file.seek(0);
Parser parser;
QXmlSimpleReader reader;
reader.setContentHandler(&parser);
QXmlInputSource source(&file);
if (!reader.parse(source))
throw WispException(formatString("Unable to parse the file \"%s\"", strFileName.c_str()));
return parser.getRoot();
}
void tst_QXmlSchema::copyConstructor() const
{
/* Verify that we can take a const reference, and simply do a copy of a default constructed object. */
{
const QXmlSchema schema1;
QXmlSchema schema2(schema1);
}
/* Copy twice. */
{
const QXmlSchema schema1;
QXmlSchema schema2(schema1);
QXmlSchema schema3(schema2);
}
/* Verify that copying default values works. */
{
const QXmlSchema schema1;
const QXmlSchema schema2(schema1);
QCOMPARE(schema2.messageHandler(), schema1.messageHandler());
QCOMPARE(schema2.uriResolver(), schema1.uriResolver());
QCOMPARE(schema2.networkAccessManager(), schema1.networkAccessManager());
QCOMPARE(schema2.isValid(), schema1.isValid());
}
}
void tst_QXmlSchema::loadSchemaUrlFail() const
{
const QUrl url("http://notavailable/");
QXmlSchema schema;
QVERIFY(!schema.load(url));
}
//! [3]
void MainWindow::validate()
{
const QByteArray schemaData = schemaView->toPlainText().toUtf8();
const QByteArray instanceData = instanceEdit->toPlainText().toUtf8();
MessageHandler messageHandler;
QXmlSchema schema;
schema.setMessageHandler(&messageHandler);
schema.load(schemaData);
bool errorOccurred = false;
if (!schema.isValid()) {
errorOccurred = true;
} else {
QXmlSchemaValidator validator(schema);
if (!validator.validate(instanceData))
errorOccurred = true;
}
if (errorOccurred) {
validationStatus->setText(messageHandler.statusMessage());
moveCursor(messageHandler.line(), messageHandler.column());
} else {
validationStatus->setText(tr("validation successful"));
}
const QString styleSheet = QString("QLabel {background: %1; padding: 3px}")
.arg(errorOccurred ? QColor(Qt::red).lighter(160).name() :
QColor(Qt::green).lighter(160).name());
validationStatus->setStyleSheet(styleSheet);
}
int XMLQtInterface::isValid() const
{
QXmlSchema schema;
if(_schemaName.length() > 0)
schema.load( QUrl::fromLocalFile((QString::fromStdString(_schemaName))) );
if ( schema.isValid() )
{
QXmlSchemaValidator validator( schema );
if ( validator.validate( _fileData ) )
return 1;
else
{
INFO("XMLQtInterface::isValid(): XML file %s is invalid (in reference to schema %s).",
_fileName.toStdString().c_str(), _schemaName.c_str());
}
}
else
{
// The following validator (without constructor arguments) automatically
// searches for the xsd given in the xml file.
QXmlSchemaValidator validator;
if ( validator.validate( _fileData ) )
return 1;
else
{
INFO("XMLQtInterface::isValid(): XML file %s is invalid (in reference to its schema).",
_fileName.toStdString().c_str());
}
}
return 0;
}
ErrorResult validateXML(const QString &fileName, const QString &schemaFileName)
{
QXmlSchema schema;
schema.load(QUrl(schemaFileName));
MessageHandler schemaMessageHandler;
schema.setMessageHandler(&schemaMessageHandler);
if (!schema.isValid())
return ErrorResult(ErrorResultType_Critical, QObject::tr("Schena '%1' is not valid. %2").
arg(schemaFileName).
arg(schemaMessageHandler.statusMessage()));
QFile file(fileName);
file.open(QIODevice::ReadOnly);
QXmlSchemaValidator validator(schema);
MessageHandler validatorMessageHandler;
validator.setMessageHandler(&validatorMessageHandler);
//TODO neslo mi nacist soubor se dvema poli
// if (!validator.validate(&file, QUrl::fromLocalFile(file.fileName())))
// return ErrorResult(ErrorResultType_Critical, QObject::tr("File '%1' is not valid Agros2D problem file. Error (line %3, column %4): %2").
// arg(fileName).
// arg(validatorMessageHandler.statusMessage()).
// arg(validatorMessageHandler.line()).
// arg(validatorMessageHandler.column()));
return ErrorResult();
}
static Score::FileError doValidate(const QString& name, QIODevice* dev)
{
QTime t;
t.start();
// initialize the schema
ValidatorMessageHandler messageHandler;
QXmlSchema schema;
schema.setMessageHandler(&messageHandler);
if (!initMusicXmlSchema(schema))
return Score::FileError::FILE_BAD_FORMAT; // appropriate error message has been printed by initMusicXmlSchema
// validate the data
QXmlSchemaValidator validator(schema);
bool valid = validator.validate(dev, QUrl::fromLocalFile(name));
qDebug("Validation time elapsed: %d ms", t.elapsed());
if (valid)
qDebug("importMusicXml() file '%s' is a valid MusicXML file", qPrintable(name));
else {
qDebug("importMusicXml() file '%s' is not a valid MusicXML file", qPrintable(name));
MScore::lastError = QObject::tr("File '%1' is not a valid MusicXML file").arg(name);
if (MScore::noGui)
return Score::FileError::FILE_NO_ERROR; // might as well try anyhow in converter mode
if (musicXMLValidationErrorDialog(MScore::lastError, messageHandler.getErrors()) != QMessageBox::Yes)
return Score::FileError::FILE_USER_ABORT;
}
// return OK
return Score::FileError::FILE_NO_ERROR;
}
static bool initMusicXmlSchema(QXmlSchema& schema)
{
// read the MusicXML schema from the application resources
QFile schemaFile(":/schema/musicxml.xsd");
if (!schemaFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug("initMusicXmlSchema() could not open resource musicxml.xsd");
MScore::lastError = QObject::tr("Internal error: Could not open resource musicxml.xsd\n");
return false;
}
// copy the schema into a QByteArray and fixup xs:imports,
// using a path to the application resources instead of to www.musicxml.org
// to prevent downloading from the net
QByteArray schemaBa;
QTextStream schemaStream(&schemaFile);
while (!schemaStream.atEnd()) {
QString line = schemaStream.readLine();
if (line.contains("xs:import"))
line.replace("http://www.musicxml.org/xsd", "qrc:///schema");
schemaBa += line.toUtf8();
schemaBa += "\n";
}
// load and validate the schema
schema.load(schemaBa);
if (!schema.isValid()) {
qDebug("initMusicXmlSchema() internal error: MusicXML schema is invalid");
MScore::lastError = QObject::tr("Internal error: MusicXML schema is invalid\n");
return false;
}
return true;
}
void tst_QXmlSchema::networkAccessManagerDefaultValue() const
{
/* Test that the default value of network access manager is not empty. */
{
QXmlSchema schema;
QVERIFY(schema.networkAccessManager() != static_cast<QNetworkAccessManager*>(0));
}
}
void tst_QXmlSchema::networkAccessManagerSignature() const
{
/* Const object. */
const QXmlSchema schema;
/* The function should be const. */
schema.networkAccessManager();
}
void tst_QXmlSchema::loadSchemaDataFail() const
{
// empty schema can not be loaded
const QByteArray data;
QXmlSchema schema;
QVERIFY(!schema.load(data));
}
void tst_QXmlSchema::messageHandlerDefaultValue() const
{
/* Test that the default value of message handler is not empty. */
{
QXmlSchema schema;
QVERIFY(schema.messageHandler() != static_cast<QAbstractMessageHandler*>(0));
}
}
void tst_QXmlSchema::uriResolverDefaultValue() const
{
/* Test that the default value of uri resolver is empty. */
{
QXmlSchema schema;
QVERIFY(schema.uriResolver() == static_cast<QAbstractUriResolver*>(0));
}
}
void tst_QXmlSchema::messageHandlerSignature() const
{
/* Const object. */
const QXmlSchema schema;
/* The function should be const. */
schema.messageHandler();
}
void tst_QXmlSchema::networkAccessManager() const
{
/* Test that we return the network manager that was set. */
{
QNetworkAccessManager manager;
QXmlSchema schema;
schema.setNetworkAccessManager(&manager);
QCOMPARE(schema.networkAccessManager(), &manager);
}
}
QXmlSchema ResourceInterface::loadXmlSchema(const QString &schemeName) const
{
QString relPath = QString("schemes/%1.xsd").arg(schemeName);
QUrl file = QUrl::fromLocalFile(QStandardPaths::locate(QStandardPaths::GenericDataLocation, "artikulate/" + relPath));
QXmlSchema schema;
if (file.isEmpty() || schema.load(file) == false) {
qCWarning(ARTIKULATE_LOG) << "Schema at file " << file.toLocalFile() << " is invalid.";
}
return schema;
}
void tst_QXmlSchema::uriResolver() const
{
/* Test that we return the uri resolver that was set. */
{
TestURIResolver resolver;
QXmlSchema schema;
schema.setUriResolver(&resolver);
QCOMPARE(schema.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));
}
}
QXmlSchema TestLanguageFiles::loadXmlSchema(const QString &schemeName) const
{
QString relPath = QString("schemes/%1.xsd").arg(schemeName);
QUrl file = QUrl::fromLocalFile(QStandardPaths::locate(QStandardPaths::DataLocation, relPath));
QXmlSchema schema;
if (schema.load(file) == false) {
qWarning() << "Schema at file " << file.toLocalFile() << " is invalid.";
}
return schema;
}
void tst_QXmlSchema::messageHandler() const
{
/* Test that we return the message handler that was set. */
{
MessageSilencer handler;
QXmlSchema schema;
schema.setMessageHandler(&handler);
QCOMPARE(schema.messageHandler(), static_cast<QAbstractMessageHandler *>(&handler));
}
}
void Schema::loadFromUrl() const
{
//! [0]
QUrl url("http://www.schema-example.org/myschema.xsd");
QXmlSchema schema;
if (schema.load(url) == true)
qDebug() << "schema is valid";
else
qDebug() << "schema is invalid";
//! [0]
}
bool PairsTheme::isValid(const KArchiveFile* file) {
KUrl schemaUrl = KUrl::fromLocalFile(KGlobal::dirs()->findResource("appdata", QLatin1String( "themes/game.xsd" )));
QXmlSchema schema;
schema.load(schemaUrl);
if(!schema.isValid()) {
qWarning() << "game Schema not valid";
return false;
}
QXmlSchemaValidator validator(schema);
return validator.validate(file->data());
}
void tst_QXmlSchema::loadSchemaDataSuccess() const
{
const QByteArray data( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<xsd:schema"
" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\""
" xmlns=\"http://qt.nokia.com/xmlschematest\""
" targetNamespace=\"http://qt.nokia.com/xmlschematest\""
" version=\"1.0\""
" elementFormDefault=\"qualified\">"
"</xsd:schema>" );
QXmlSchema schema;
QVERIFY(schema.load(data));
}
void Fenetre::ouvrir()
{
QString fileName = QFileDialog::getOpenFileName(this, tr("Séléctionner un fichier"),
QDir::currentPath(),
tr("Fichiers XML (*.xml)"));
if (fileName.isEmpty())
return;
QFile fileXML(fileName);
if (!fileXML.open(QFile::ReadOnly | QFile::Text)) {
QMessageBox::warning(this, tr("Erreur lecture"),
tr("Impossible de lire le fichier %1:\n%2.")
.arg(fileName)
.arg(fileXML.errorString()));
return;
}
QFile fileSchema("schemaGraph.xsd");
fileSchema.open(QIODevice::ReadOnly);
QXmlSchema schema;
MessageHandler messageHandler;
schema.setMessageHandler(&messageHandler);
schema.load(&fileSchema, QUrl::fromLocalFile(fileSchema.fileName()));
if (schema.isValid()) {
QFile fileXML2(fileName);
fileXML2.open(QIODevice::ReadOnly);
QXmlSchemaValidator validator(schema);
if (!validator.validate(&fileXML2, QUrl::fromLocalFile(fileXML2.fileName()))){
QMessageBox::warning(this, tr("Fichier malformé"),
tr("Impossible d'ouvrir le fichier' %1'.\n Le document ne correspond pas au schéma. \n%2")
.arg(fileName)
.arg(messageHandler.statusMessage()));
return;
}
}
ImportExport import=ImportExport(&graphe,xmltree, affichageSVG);
if (import.ouvrir(&fileXML, &domDocument))
ui->statusBar->showMessage(tr("Fichier chargé"), 2000);
affichageSVG->drawGraph();
ui->afficheGraphe->adjustSize();
//On pense à remettre la liste des sommets pour créer les arcs
redessinerComboArc();
}
void Schema::loadFromFile() const
{
//! [1]
QFile file("myschema.xsd");
file.open(QIODevice::ReadOnly);
QXmlSchema schema;
schema.load(&file, QUrl::fromLocalFile(file.fileName()));
if (schema.isValid())
qDebug() << "schema is valid";
else
qDebug() << "schema is invalid";
//! [1]
}
void tst_QXmlSchema::uriResolverSignature() const
{
/* Const object. */
const QXmlSchema schema;
/* The function should be const. */
schema.uriResolver();
/* Const object. */
const TestURIResolver resolver;
/* This should compile */
QXmlSchema schema2;
schema2.setUriResolver(&resolver);
}
MerDevicesXmlReader::MerDevicesXmlReader(const QString &fileName, QObject *parent)
: QObject(parent),
d(new MerDevicesXmlReaderPrivate)
{
Utils::FileReader reader;
d->error = !reader.fetch(fileName, QIODevice::ReadOnly);
if (d->error) {
d->errorString = reader.errorString();
return;
}
QXmlSchema schema;
schema.setMessageHandler(&d->messageHandler);
Utils::FileReader schemeReader;
d->error = !schemeReader.fetch(QString::fromLatin1("%1/mer/devices.xsd").arg(sharedDirPath()),
QIODevice::ReadOnly);
if (d->error) {
d->errorString = schemeReader.errorString();
return;
}
schema.load(schemeReader.data());
d->error = !schema.isValid();
if (d->error) {
d->errorString = d->messageHandler.errorString();
return;
}
QXmlSchemaValidator validator(schema);
validator.setMessageHandler(&d->messageHandler);
d->error = !validator.validate(reader.data());
if (d->error) {
d->errorString = d->messageHandler.errorString();
return;
}
d->query.setQuery(QString::fromLatin1("doc('%1')").arg(fileName));
d->query.setMessageHandler(&d->messageHandler);
d->error = !d->query.isValid();
if (d->error) {
d->errorString = d->messageHandler.errorString();
return;
}
d->error = !d->query.evaluateTo(d->receiver);
if (d->error)
d->errorString = d->messageHandler.errorString();
}
QObject * LanguageResource::resource()
{
if (d->m_languageResource != 0) {
return d->m_languageResource;
}
if (!d->m_path.isLocalFile()) {
qWarning() << "Cannot open language file at " << d->m_path.toLocalFile() << ", aborting.";
return 0;
}
QXmlSchema schema = loadXmlSchema("language");
if (!schema.isValid()) {
return 0;
}
QDomDocument document = loadDomDocument(d->m_path, schema);
if (document.isNull()) {
qWarning() << "Could not parse document " << d->m_path.toLocalFile() << ", aborting.";
return 0;
}
QDomElement root(document.documentElement());
d->m_languageResource = new Language(this);
d->m_languageResource->setFile(d->m_path);
d->m_languageResource->setId(root.firstChildElement("id").text());
d->m_languageResource->setTitle(root.firstChildElement("title").text());
d->m_languageResource->seti18nTitle(root.firstChildElement("i18nTitle").text());
// create phoneme groups
for (QDomElement groupNode = root.firstChildElement("phonemeGroups").firstChildElement();
!groupNode.isNull();
groupNode = groupNode.nextSiblingElement())
{
PhonemeGroup *group = d->m_languageResource->addPhonemeGroup(
groupNode.firstChildElement("id").text(),
groupNode.firstChildElement("title").text());
group->setDescription(groupNode.attribute("description"));
// register phonemes
for (QDomElement phonemeNode = groupNode.firstChildElement("phonemes").firstChildElement();
!phonemeNode.isNull();
phonemeNode = phonemeNode.nextSiblingElement())
{
group->addPhoneme(phonemeNode.firstChildElement("id").text(), phonemeNode.firstChildElement("title").text());
}
}
return d->m_languageResource;
}
void tst_QXmlSchema::loadSchemaDeviceSuccess() const
{
QByteArray data( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<xsd:schema"
" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\""
" xmlns=\"http://qt.nokia.com/xmlschematest\""
" targetNamespace=\"http://qt.nokia.com/xmlschematest\""
" version=\"1.0\""
" elementFormDefault=\"qualified\">"
"</xsd:schema>" );
QBuffer buffer(&data);
buffer.open(QIODevice::ReadOnly);
QXmlSchema schema;
QVERIFY(schema.load(&buffer));
}
void tst_QXmlSchema::loadSchemaDeviceFail() const
{
QByteArray data( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<xsd:schema"
" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\""
" xmlns=\"http://qt.nokia.com/xmlschematest\""
" targetNamespace=\"http://qt.nokia.com/xmlschematest\""
" version=\"1.0\""
" elementFormDefault=\"qualified\">"
"</xsd:schema>" );
QBuffer buffer(&data);
// a closed device can not be loaded
QXmlSchema schema;
QVERIFY(!schema.load(&buffer));
}
