je m'occupe d'un programme dont le but est de tester toutes les
fonctionnalit=E9s offertes par une librairie.
Cette librairie s'enrichit parfois de nouvelles fonctions mais garde
toujours les pr=E9c=E9dentes (d'o=F9 mon expression compilation
"incr=E9mentale").
Chaque version de librairie est localis=E9e dans un r=E9pertoire
diff=E9rent.
Je dois m'assurer qu'il n'y a pas de r=E9gression entre les diff=E9rentes
versions de la librairie.
Je me retrouve donc confront=E9 au soucis de devoir compiler mon
programme de test (C++), qui est unique, avec diff=E9rentes versions de
librairie ne comportant pas toutes les m=E9thodes offertes par la
derni=E8re version.
Alors comment faire ?
Peut-on =E9crire quelque chose dans le genre :
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Alexandre
bonjour,
"Picard" a écrit dans le message de news:
Bonjour,
je m'occupe d'un programme dont le but est de tester toutes les fonctionnalités offertes par une librairie.
petite remarque en passant : une bibliothèque (library en anglais, gare aux faux amis)
Cette librairie s'enrichit parfois de nouvelles fonctions mais garde toujours les précédentes (d'où mon expression compilation "incrémentale"). Chaque version de librairie est localisée dans un répertoire différent.
Je dois m'assurer qu'il n'y a pas de régression entre les différentes versions de la librairie.
Je me retrouve donc confronté au soucis de devoir compiler mon programme de test (C++), qui est unique, avec différentes versions de librairie ne comportant pas toutes les méthodes offertes par la dernière version.
Alors comment faire ? Peut-on écrire quelque chose dans le genre :
à peu près, mais en utilisant des #define et des #ifdef #ifndef ou alors 2e solution : placer chaque lib dans un namespace différent (genre namespace VER1, VER2, etc...) puis faire le using namespace nécessaire dans le test pour passer d'une version à l'autre
bonjour,
"Picard" <atom120@libertysurf.fr> a écrit dans le message de news:
je m'occupe d'un programme dont le but est de tester toutes les
fonctionnalités offertes par une librairie.
petite remarque en passant : une bibliothèque (library en anglais, gare aux
faux amis)
Cette librairie s'enrichit parfois de nouvelles fonctions mais garde
toujours les précédentes (d'où mon expression compilation
"incrémentale").
Chaque version de librairie est localisée dans un répertoire
différent.
Je dois m'assurer qu'il n'y a pas de régression entre les différentes
versions de la librairie.
Je me retrouve donc confronté au soucis de devoir compiler mon
programme de test (C++), qui est unique, avec différentes versions de
librairie ne comportant pas toutes les méthodes offertes par la
dernière version.
Alors comment faire ?
Peut-on écrire quelque chose dans le genre :
à peu près, mais en utilisant des #define et des #ifdef #ifndef
ou alors 2e solution : placer chaque lib dans un namespace différent (genre
namespace VER1, VER2, etc...)
puis faire le using namespace nécessaire dans le test pour passer d'une
version à l'autre
je m'occupe d'un programme dont le but est de tester toutes les fonctionnalités offertes par une librairie.
petite remarque en passant : une bibliothèque (library en anglais, gare aux faux amis)
Cette librairie s'enrichit parfois de nouvelles fonctions mais garde toujours les précédentes (d'où mon expression compilation "incrémentale"). Chaque version de librairie est localisée dans un répertoire différent.
Je dois m'assurer qu'il n'y a pas de régression entre les différentes versions de la librairie.
Je me retrouve donc confronté au soucis de devoir compiler mon programme de test (C++), qui est unique, avec différentes versions de librairie ne comportant pas toutes les méthodes offertes par la dernière version.
Alors comment faire ? Peut-on écrire quelque chose dans le genre :
à peu près, mais en utilisant des #define et des #ifdef #ifndef ou alors 2e solution : placer chaque lib dans un namespace différent (genre namespace VER1, VER2, etc...) puis faire le using namespace nécessaire dans le test pour passer d'une version à l'autre
kanze
Picard wrote:
je m'occupe d'un programme dont le but est de tester toutes les fonctionnalités offertes par une librairie. Cette librairie s'enrichit parfois de nouvelles fonctions mais garde toujours les précédentes (d'où mon expression compilation "incrémentale"). Chaque version de librairie est localisée dans un répertoire différent.
Je dois m'assurer qu'il n'y a pas de régression entre les différentes versions de la librairie.
Je ne suis pas sûr de comprendre. Les anciennes versions évolvent aussi, pour qu'il y a besoin de les tester ? Ou est-ce que tu entends par « version » différentes versions livrées aux clients, plus ou moins complètes, selon que le client a payé plus ou moins ?
Je me retrouve donc confronté au soucis de devoir compiler mon programme de test (C++), qui est unique, avec différentes versions de librairie ne comportant pas toutes les méthodes offertes par la dernière version.
Alors comment faire ? Peut-on écrire quelque chose dans le genre :
On pourrait, mais ça devient vite impossible à maintenir, et ça créer autant de versions de test qu'il y a de versions de la bibliothèque (ce qui est peut-être inévitable -- il faut au minimum des objets dynamiques différents selon la version).
J'aurais plutôt tendance à créer une version de base, avec tout ce qui se trouve partout, et puis des ajoutes (en forme d'objet dynamique) pour chaque ensemble de fonctionnalité qu'on ajoute au produit. Ensuite, tu charges les objets dynamiques selon un fichier de configuration, qui dit ce qu'il faut tester. Arrive une nouvelle version du produit à tester, tu crées un nouvel objet dynamique pour tester les nouvelles fonctionnalités, sans toucher au programme de test ne aux tests existants.
Mes connaissances en compilation étant assez limitées, j'aimerais savoir s'il existe une solution élégante à ce problème.
Je dirais qu'ici, c'est bien un cas où l'édition de liens dynamiques se justifie.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Picard wrote:
je m'occupe d'un programme dont le but est de tester toutes
les fonctionnalités offertes par une librairie. Cette
librairie s'enrichit parfois de nouvelles fonctions mais garde
toujours les précédentes (d'où mon expression compilation
"incrémentale").
Chaque version de librairie est localisée dans un répertoire
différent.
Je dois m'assurer qu'il n'y a pas de régression entre les
différentes versions de la librairie.
Je ne suis pas sûr de comprendre. Les anciennes versions
évolvent aussi, pour qu'il y a besoin de les tester ? Ou est-ce
que tu entends par « version » différentes versions livrées
aux clients, plus ou moins complètes, selon que le client a payé
plus ou moins ?
Je me retrouve donc confronté au soucis de devoir compiler mon
programme de test (C++), qui est unique, avec différentes
versions de librairie ne comportant pas toutes les méthodes
offertes par la dernière version.
Alors comment faire ?
Peut-on écrire quelque chose dans le genre :
On pourrait, mais ça devient vite impossible à maintenir, et ça
créer autant de versions de test qu'il y a de versions de la
bibliothèque (ce qui est peut-être inévitable -- il faut au
minimum des objets dynamiques différents selon la version).
J'aurais plutôt tendance à créer une version de base, avec tout
ce qui se trouve partout, et puis des ajoutes (en forme d'objet
dynamique) pour chaque ensemble de fonctionnalité qu'on ajoute
au produit. Ensuite, tu charges les objets dynamiques selon un
fichier de configuration, qui dit ce qu'il faut tester. Arrive
une nouvelle version du produit à tester, tu crées un nouvel
objet dynamique pour tester les nouvelles fonctionnalités, sans
toucher au programme de test ne aux tests existants.
Mes connaissances en compilation étant assez limitées,
j'aimerais savoir s'il existe une solution élégante à ce
problème.
Je dirais qu'ici, c'est bien un cas où l'édition de liens
dynamiques se justifie.
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
je m'occupe d'un programme dont le but est de tester toutes les fonctionnalités offertes par une librairie. Cette librairie s'enrichit parfois de nouvelles fonctions mais garde toujours les précédentes (d'où mon expression compilation "incrémentale"). Chaque version de librairie est localisée dans un répertoire différent.
Je dois m'assurer qu'il n'y a pas de régression entre les différentes versions de la librairie.
Je ne suis pas sûr de comprendre. Les anciennes versions évolvent aussi, pour qu'il y a besoin de les tester ? Ou est-ce que tu entends par « version » différentes versions livrées aux clients, plus ou moins complètes, selon que le client a payé plus ou moins ?
Je me retrouve donc confronté au soucis de devoir compiler mon programme de test (C++), qui est unique, avec différentes versions de librairie ne comportant pas toutes les méthodes offertes par la dernière version.
Alors comment faire ? Peut-on écrire quelque chose dans le genre :
On pourrait, mais ça devient vite impossible à maintenir, et ça créer autant de versions de test qu'il y a de versions de la bibliothèque (ce qui est peut-être inévitable -- il faut au minimum des objets dynamiques différents selon la version).
J'aurais plutôt tendance à créer une version de base, avec tout ce qui se trouve partout, et puis des ajoutes (en forme d'objet dynamique) pour chaque ensemble de fonctionnalité qu'on ajoute au produit. Ensuite, tu charges les objets dynamiques selon un fichier de configuration, qui dit ce qu'il faut tester. Arrive une nouvelle version du produit à tester, tu crées un nouvel objet dynamique pour tester les nouvelles fonctionnalités, sans toucher au programme de test ne aux tests existants.
Mes connaissances en compilation étant assez limitées, j'aimerais savoir s'il existe une solution élégante à ce problème.
Je dirais qu'ici, c'est bien un cas où l'édition de liens dynamiques se justifie.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Picard
Bonjour,
kanze wrote:
Picard wrote:
Je ne suis pas sûr de comprendre. Les anciennes versions évolvent aussi, pour qu'il y a besoin de les tester ? Ou est-ce que tu entends par « version » différentes versions livrées aux clients, plus ou moins complètes, selon que le client a payé plus ou moins ?
Non, rien de tout cela. Le client utilise plusieurs versions de la librairie sur différents sites et mon programme de test utilisant cette librairie s'enrichit avec le temps.
On pourrait, mais ça devient vite impossible à maintenir, et ça créer autant de versions de test qu'il y a de versions de la bibliothèque (ce qui est peut-être inévitable -- il faut au minimum des objets dynamiques différents selon la version).
L'interface offerte par la librairie évolue rarement: cette solution pourrait donc être envisagée dans mon cas.
J'aurais plutôt tendance à créer une version de base, avec tout ce qui se trouve partout, et puis des ajoutes (en forme d'objet dynamique) pour chaque ensemble de fonctionnalité qu'on ajoute au produit. Ensuite, tu charges les objets dynamiques selon un fichier de configuration, qui dit ce qu'il faut tester. Arrive une nouvelle version du produit à tester, tu crées un nouvel objet dynamique pour tester les nouvelles fonctionnalités, sans toucher au programme de test ne aux tests existants.
Je dirais qu'ici, c'est bien un cas où l'édition de liens dynamiques se justifie.
Merci! Cette solution me plaît bien. Cela répond tout à fait à ma contrainte.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Bonjour,
kanze wrote:
Picard wrote:
Je ne suis pas sûr de comprendre. Les anciennes versions
évolvent aussi, pour qu'il y a besoin de les tester ? Ou est-ce
que tu entends par « version » différentes versions livrées
aux clients, plus ou moins complètes, selon que le client a payé
plus ou moins ?
Non, rien de tout cela.
Le client utilise plusieurs versions de la librairie sur différents
sites et mon programme de test utilisant cette librairie s'enrichit
avec le temps.
On pourrait, mais ça devient vite impossible à maintenir, et ça
créer autant de versions de test qu'il y a de versions de la
bibliothèque (ce qui est peut-être inévitable -- il faut au
minimum des objets dynamiques différents selon la version).
L'interface offerte par la librairie évolue rarement: cette solution
pourrait donc être envisagée dans mon cas.
J'aurais plutôt tendance à créer une version de base, avec tout
ce qui se trouve partout, et puis des ajoutes (en forme d'objet
dynamique) pour chaque ensemble de fonctionnalité qu'on ajoute
au produit. Ensuite, tu charges les objets dynamiques selon un
fichier de configuration, qui dit ce qu'il faut tester. Arrive
une nouvelle version du produit à tester, tu crées un nouvel
objet dynamique pour tester les nouvelles fonctionnalités, sans
toucher au programme de test ne aux tests existants.
Je dirais qu'ici, c'est bien un cas où l'édition de liens
dynamiques se justifie.
Merci!
Cette solution me plaît bien. Cela répond tout à fait à ma
contrainte.
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Je ne suis pas sûr de comprendre. Les anciennes versions évolvent aussi, pour qu'il y a besoin de les tester ? Ou est-ce que tu entends par « version » différentes versions livrées aux clients, plus ou moins complètes, selon que le client a payé plus ou moins ?
Non, rien de tout cela. Le client utilise plusieurs versions de la librairie sur différents sites et mon programme de test utilisant cette librairie s'enrichit avec le temps.
On pourrait, mais ça devient vite impossible à maintenir, et ça créer autant de versions de test qu'il y a de versions de la bibliothèque (ce qui est peut-être inévitable -- il faut au minimum des objets dynamiques différents selon la version).
L'interface offerte par la librairie évolue rarement: cette solution pourrait donc être envisagée dans mon cas.
J'aurais plutôt tendance à créer une version de base, avec tout ce qui se trouve partout, et puis des ajoutes (en forme d'objet dynamique) pour chaque ensemble de fonctionnalité qu'on ajoute au produit. Ensuite, tu charges les objets dynamiques selon un fichier de configuration, qui dit ce qu'il faut tester. Arrive une nouvelle version du produit à tester, tu crées un nouvel objet dynamique pour tester les nouvelles fonctionnalités, sans toucher au programme de test ne aux tests existants.
Je dirais qu'ici, c'est bien un cas où l'édition de liens dynamiques se justifie.
Merci! Cette solution me plaît bien. Cela répond tout à fait à ma contrainte.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Picard
Bonjour et merci pour votre aide.
Alexandre wrote:
petite remarque en passant : une bibliothèque (library en anglais, gare aux faux amis)
Il s'agit en fait d'une erreur liée à l'habitude. Mais c'était
à peu près, mais en utilisant des #define et des #ifdef #ifndef
là, je ne vois pas comment faire avec des #define ?
ou alors 2e solution : placer chaque lib dans un namespace différent (g enre namespace VER1, VER2, etc...) puis faire le using namespace nécessaire dans le test pour passer d'une version à l'autre
Je ne souhaite pas avoir toutes les versions de librairie associées au même binaire: je ne pense donc pas que cette solution puisse me convenir.
Bonjour et merci pour votre aide.
Alexandre wrote:
petite remarque en passant : une bibliothèque (library en anglais, gare aux
faux amis)
Il s'agit en fait d'une erreur liée à l'habitude. Mais c'était
à peu près, mais en utilisant des #define et des #ifdef #ifndef
là, je ne vois pas comment faire avec des #define ?
ou alors 2e solution : placer chaque lib dans un namespace différent (g enre
namespace VER1, VER2, etc...)
puis faire le using namespace nécessaire dans le test pour passer d'une
version à l'autre
Je ne souhaite pas avoir toutes les versions de librairie associées au
même binaire: je ne pense donc pas que cette solution puisse me
convenir.
à peu près, mais en utilisant des #define et des #ifdef #ifndef
là, je ne vois pas comment faire avec des #define ?
ou alors 2e solution : placer chaque lib dans un namespace différent (g enre namespace VER1, VER2, etc...) puis faire le using namespace nécessaire dans le test pour passer d'une version à l'autre
Je ne souhaite pas avoir toutes les versions de librairie associées au même binaire: je ne pense donc pas que cette solution puisse me convenir.
