int main()
{
sf::Window win(sf::VideoMode(sf::VideoMode::getDesktopMode()), "Sphere"); //création fenêtre principale
win.setVerticalSyncEnabled(true);
win.setFramerateLimit(60);
glMatrixMode(GL_PROJECTION); //init OPENGL
glLoadIdentity();
gluPerspective(70, (double)win.getSize().x / win.getSize().y, 1, 1000);
glEnable(GL_DEPTH);
Camera cam(0, 1, 5,sf::Mouse::getPosition(win).x, sf::Mouse::getPosition(win).y, &win); //création de la caméra
win.setMouseCursorVisible(false);
bool running = true; //invariant de boucle
while (running) //boucle fenêtre principale
{
sf::Event event;
while (win.pollEvent(event)) //évènements
{
if (event.type == sf::Event::Closed)
running = false;
else if (event.type == sf::Event::KeyPressed)
{
cam.get_event(event);
if (event.key.code == sf::Keyboard::Escape)
{
running = false;
}
}
else if (event.type == sf::Event::MouseMoved)
{
cam.get_event(event);
}
}
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //**********************DISPLAY******************
cam.use_cam();
repere();
win.display();
}
return 0;
}
// ----------------------------------------------------------------------------
int main( int nombreDArguments, char *arguments[ ] )
// ----------------------------------------------------------------------------
{
char *nomDuFichierDeCorrection = "correction.txt";
if ( nombreDArguments == 2 ) {
nomDuFichierDeCorrection = arguments[ 1 ];
}
ofstream correction = ofstream( nomDuFichierDeCorrection, ios::out );
if ( correction == 0 ) {
cerr << "Echec de l'ouverture de \"" << nomDuFichierDeCorrection
<< "\"" << endl;
return 1;
}
char message[ 1024 ];
double valeur;
bool continuer = true;
double noteMax = 0.0;
double note = 0.0;
unsigned int numeroDeTest = 0;
EntierBorne unite;
/*
* test des limites d'un EntierBorne implicite.
*/
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( unite.fournirMinimum( ) != 0 ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMinimum( ) d'un EntierBorne implicite devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"etre 0.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( unite.fournirMaximum( ) != 1 ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"etre 1.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( unite.fournirValeur( ) != 0 ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"etre 1.\n" );
rapporter( correction, message );
}
}
int minimum = 0;
int maximum = 10;
EntierBorne indice( minimum, maximum );
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( indice.fournirMinimum( ) != minimum ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMinimum( ) d'un EntierBorne implicite devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"etre 0.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( indice.fournirMaximum( ) != maximum ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"etre 1.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( indice.fournirValeur( ) != minimum ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"etre 1.\n" );
rapporter( correction, message );
}
}
indice.fixerAuMaximum( );
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( indice.fournirValeur( ) != maximum ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"etre 1.\n" );
rapporter( correction, message );
}
}
indice.fixerAuMinimum( );
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( indice.fournirValeur( ) != minimum ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"etre 1.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
indice.modifierValeur( maximum + 1 );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( !exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) exception HorsBornes non declenchee dans\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"modifierValeur().\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
indice.modifierValeur( minimum - 1 );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( !exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) exception HorsBornes non declenchee dans\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"modifierValeur().\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
indice.modifierValeur( maximum );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) exception HorsBornes declenchee pour valeur = maximum dans\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"modifierValeur().\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
indice.modifierValeur( minimum );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) exception HorsBornes declenchee pour valeur = minimum dans\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"modifierValeur().\n" );
rapporter( correction, message );
}
}
IntervalleEntier intervalle( minimum, maximum );
EntierBorne repere( intervalle );
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( repere.fournirMinimum( ) != minimum ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMinimum( ) d'un EntierBorne construit sur un\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"IntervalleEntier [0..10] devrait renvoyer 0.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( repere.fournirMaximum( ) != maximum ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fournirMinimum( ) d'un EntierBorne construit sur un\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"IntervalleEntier [0..10] devrait renvoyer 10.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
repere.modifierValeur(( maximum + minimum )/2 );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fixer un EntierBorne au milieur de son IntervalleEntier\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"ne devrait pas declencher d'exception.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
repere.modifierValeur( maximum + 1 );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( !exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fixer un EntierBorne au dessus de son maximum\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"devrait declencher l'exception HorsBornes.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
repere.modifierValeur( minimum - 1 );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( !exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fixer un EntierBorne au dessous de son minimum\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"devrait declencher l'exception HorsBornes.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
repere.modifierValeur( minimum );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fixer un EntierBorne a son minimum ne devrait pas\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"declencher d'exception.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
repere.modifierValeur( maximum );
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) fixer un EntierBorne a son maximum ne devrait pas\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"declencher d'exception.\n" );
rapporter( correction, message );
}
}
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
bool exceptionCapturee = false;
try {
repere++;
}
catch( EntierBorne::HorsBornes ) {
exceptionCapturee = true;
}
if ( !exceptionCapturee ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) decrementer un EntierBorne en dessous de son minimum devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"declencher l'exception HorsBornes.\n" );
rapporter( correction, message );
}
}
int notes[ 10 ];
EntierBorne index( 0, 10 );
notes[ 3 ] = 3;
numeroDeTest++;
valeur = 10.0;
noteMax += valeur;
note -= valeur;
if ( continuer ) {
note += valeur;
if ( notes[ 3 ] != 3 ) {
note -= valeur;
continuer = false;
char *pt = message;
sprintf( pt,
"(%u) Un EntierBorne utiliser en indice de tableau devrait\n",
numeroDeTest );
sprintf( pt += strlen( pt ),
"acceder a la cellule correspondant a sa valeur.\n" );
rapporter( correction, message );
}
}
/* ----------------------------- service --------------------------------- */
note += noteMax;
note = note/noteMax;
sprintf( message, "note obtenue: %6.2lf.\n", note );
rapporter( correction, message );
return 0;
}
