FORUMS PROFESSIONNELS
WINDEV
,
WEBDEV
et
WINDEV Mobile
Accueil
|
Messages récents
|
Connexion
|
Déconnexion
|
Français
Accueil
→
WINDEV 2024
→
Parcours d'un XML et comportemens incohérents sur XMLTrouve, XMLEnDehors et XMLRetourPosition
Parcours d'un XML et comportemens incohérents sur XMLTrouve, XMLEnDehors et XMLRetourPosition
Débuté par VincentRG, 09 juil. 2020 17:23 - Aucune réponse
Connectez-vous…
VincentRG
#1
Membre enregistré
12 messages
Posté le 09 juillet 2020 - 17:23
Bonjour,
Je suis sur un projet dont la base de code existe déjà, et qui comprend pas mal de parcours de fichiers XML. Ces parcours sont effectués avec les fonctions XML...(). Les variables xmlDocument, xmlNoeud, etc ne sont pas utilisées.
Cherchant à améliorer un peu les algorithmes, j'ai fait quelques tests sur ces fonctions pour comprendre leur fonctionnement (la doc est assez évasive).
J'ai noté plusieurs incohérences, que je vous livre un peu sous la forme d'un test unitaire:
s
SourceXml
est une chaîne
= [
<?xml version="1.0" encoding="UTF8"?>
<LISTE>
<PRODUIT>
<IDProduit>Produit1</IDProduit>
<IDProduit>Produit2</IDProduit>
</PRODUIT>
</LISTE>
]
s
NomDocXml
est une chaîne
=
"DocXml"
b
Res
est un booléen
=
XMLDocument
(
s
NomDocXml
,
s
SourceXml
)
dbgAssertion
(
b
Res
=
Vrai
)
b
Retour
est un booléen
=
Faux
// Se positionne sur Liste
b
Retour
=
XMLRacine
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"LISTE"
)
// Se positionne sur Produit
b
Retour
=
XMLFils
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"PRODUIT"
)
// se positionne sur le premier id produit
b
Retour
=
XMLFils
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"IDProduit"
)
dbgAssertion
(
XMLDonnée
(
s
NomDocXml
) =
"Produit1"
)
// se positionne sur le 2e id produit
b
Retour
=
XMLSuivant
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"IDProduit"
)
dbgAssertion
(
XMLDonnée
(
s
NomDocXml
) =
"Produit2"
)
// sauvegarde la position du 2e id de produit
iPositionProduit2
est un entier
=
XMLSauvePosition
(
s
NomDocXml
)
dbgAssertion
(
iPositionProduit2
<
> -
1
)
// se positionne sur un noeud inexistant
b
Retour
=
XMLSuivant
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Faux
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Vrai
)
// sauvegarde la position de ce noeud invalide
iPositionInvalide
est un entier
=
XMLSauvePosition
(
s
NomDocXml
)
// aucune info dans la doc sur le comportement de cette fonction
// quand on sauvegarde une position invalide
// seulement que ça retourne -1 en cas d'erreur, ce qui devrait
// être le cas!
//============================
// >>> COMPORTEMENT INCOHERENT
//============================
dbgAssertion
(
iPositionInvalide
<
> -
1
)
// retourne sur le 2e id produit
b
Retour
=
XMLRetourPosition
(
s
NomDocXml
,
iPositionProduit2
,
XMLRPConserve
)
// XMLRetour retourne faux et XMLEnDehors retourne vrai
// à cause du XMLSuivant qui a échoué, alors qu'on est sur le bon noeud
//============================
// >>> COMPORTEMENT INCOHERENT
//============================
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"IDProduit"
)
dbgAssertion
(
XMLDonnée
(
s
NomDocXml
) =
"Produit2"
)
// on se remet à la racine
b
Retour
=
XMLRacine
(
s
NomDocXml
)
// XMLTrouve retourne vrai et XMLEnDehors qui retourne faux
// tout va bien
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"LISTE"
)
// on se remet sur le 2e id produit
b
Retour
=
XMLRetourPosition
(
s
NomDocXml
,
iPositionProduit2
,
XMLRPConserve
)
// ce coup-ci XMLTrouve renvoie vrai et XMLEnDehors renvoie faux,
// puisque qu'on s'est mis sur un noeud valide juste avant (racine)
// et non pas parce que le noeud du 2e id de produit est valide
//============================
// >>> COMPORTEMENT INCOHERENT
//============================
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"IDProduit"
)
dbgAssertion
(
XMLDonnée
(
s
NomDocXml
) =
"Produit2"
)
// supprime le 2e id produit
b
Retour
=
XMLSupprime
(
s
NomDocXml
)
// la suppression positionne sur le noeud parent
// XMLTrouve renvoie toujours vrai et XMLEnDehors faux
// mais ces retours sont en fonction de la position valide
// ou non juste avant la suppression (cf test plus bas)
// et non pas parce qu'on se retrouve sur le parent
//============================
// >>> COMPORTEMENT INCOHERENT
//============================
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"PRODUIT"
)
// retourne sur ce 2e id produit qu'on vient de supprimer.
b
Retour
=
XMLRetourPosition
(
s
NomDocXml
,
iPositionProduit2
,
XMLRPConserve
)
// la valeur de retour de XMLRetourPosition est à vrai et
// XMLTrouve renvoie vrai et XMLEnDehors renvoie faux,
// alors que ce noeud a été supprimé ! XMLRetourPosition ne
// devrait d'ailleurs pas renvoyer vrai, car on cherche à
// retourner sur un noeud supprimé.
//============================
// >>> COMPORTEMENT INCOHERENT
//============================
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
// Se positionne à la racine
b
Retour
=
XMLRacine
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"LISTE"
)
// Se positionne sur Produit
b
Retour
=
XMLFils
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"PRODUIT"
)
// se positionne sur le premier id produit
b
Retour
=
XMLFils
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"IDProduit"
)
dbgAssertion
(
XMLDonnée
(
s
NomDocXml
) =
"Produit1"
)
// sauvegarde la position du produit 1
iPositionProduit1
est un entier
=
XMLSauvePosition
(
s
NomDocXml
)
dbgAssertion
(
iPositionProduit1
<
> -
1
)
// se positionne sur suivant, qui n'existe plus
b
Retour
=
XMLSuivant
(
s
NomDocXml
)
dbgAssertion
(
b
Retour
=
Faux
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Vrai
)
// retourne sur la position de l'id produit 1
b
Retour
=
XMLRetourPosition
(
s
NomDocXml
,
iPositionProduit1
,
XMLRPConserve
)
// XMLTrouve retourne faux et XMLEnDehors Vrai,
// car on était sur une position invalide juste avant
//============================
// >>> COMPORTEMENT INCOHERENT
//============================
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"IDProduit"
)
dbgAssertion
(
XMLDonnée
(
s
NomDocXml
) =
"Produit1"
)
// supprime le produit 1
b
Retour
=
XMLSupprime
(
s
NomDocXml
)
// la suppression positionne sur le noeud parent, donc valide
// mais XMLTrouve retourne faux et XMLEnDehors vrai car
// on était sur un noeud invalide avant la suppression
//============================
// >>> COMPORTEMENT INCOHERENT
//============================
dbgAssertion
(
b
Retour
=
Vrai
)
dbgAssertion
(
XMLTrouve
(
s
NomDocXml
) =
Faux
)
dbgAssertion
(
XMLEnDehors
(
s
NomDocXml
) =
Vrai
)
dbgAssertion
(
XMLNomElément
(
s
NomDocXml
) =
"PRODUIT"
)
XMLTermine
(
s
NomDocXml
)
Tous les comportements "incohérents" sont indiqués.
Pour les résumer:
- on peut sauvegarder une position invalide dans le XML, sans avoir de retour d'erreur
- on peut faire un XMLRetourPosition (renvoie Vrai) sur un noeud qui a été supprimé
- XMLTrouve et XMLEnDehors ne prennent pas en compte le changement de position suite à un XMLSupprime (qui positionne sur le parent) ou à un XMLRetourPosition
C'est pas très jojo quand même, et ça manque de logique. Y-a-t'il une raison à tout ça?
J'ai fait quelques tests avec les variables xmlDocument, etc pour manipuler les fichiers XML. Ca semble bien fonctionner (malgré 2 ou 3 détails pas très pratique), mais je n'ai pas trouvé comment faire de recherche à la façon de XMLRecherche. Et je ne peux pas malheureusement pas modifier tout le code de parcours dans le projet.
Signaler
0
0
→ Revenir à WINDEV 2024
WINDEV 2024
WEBDEV 2024
WINDEV Mobile 2024
WINDEV (précédentes versions)
WEBDEV (précédentes versions)
WINDEV Mobile (précédentes versions)
Etats & Requêtes
Hors-sujet
Outils
Français
English
Español
Portuguesa
Fermer cette fenêtre
Type de recherche
Uniquement les sujets
Tous les messages
Période de recherche
Date indifférente
Moins d'une heure
Moins de 24 heures
Moins d'une semaine
Moins d'un mois
Moins d'un an
Annuler
Aperçu de votre message
Ajouter une image
Importer une image depuis une URL
Envoyer une image depuis un fichier de votre disque
Déposez ici un fichier ou cliquez sur "Parcourir..."
ou
Annuler
0%
WLangage
SQL
XML, HTML
JAVA, Javascript
Texte