Initial commit Testing

Testing.pro

@@ -0,0 +1,27 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2014-07-03T13:18:44
+#
+#-------------------------------------------------
+
+QT       += core gui
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+TARGET = Testing
+TEMPLATE = app
+
+
+SOURCES += main.cpp\
+        mainwindow.cpp \
+    secondwindow.cpp \
+    functions.cpp
+
+HEADERS  += mainwindow.h \
+    secondwindow.h \
+    functions.h
+
+FORMS    += mainwindow.ui
+
+RESOURCES += \
+    images.qrc

functions.cpp

@@ -0,0 +1,839 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+
+#include <QDebug>
+#include <QString>
+#include <cstdlib>
+
+#include <QMessageBox>
+#include <QMap>
+#include "functions.h"
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+
+// =========================================================
+// Sort Functions
+// =========================================================
+
+bool validateSorts(const QString &a, const QString &b, const QString &c) {
+     return (a.length() * b.length() * c.length() > 0);
+}
+
+
+void mySortAlpha(QString &a, QString &b, QString &c) {
+    if (a > b ) {
+        if (c > a)      swap(b,c);
+        else if (b > c) swap(a,b);
+        else {
+            QString tmp = a;
+            a = b; b = c; c = tmp;
+        }
+    }
+    else {
+        if (a > c) {
+            QString tmp = c;
+            c = b;  b = a; a = tmp;
+        }
+        else if (b > c) swap(b,c);
+        else {
+            // they are already in order :-)
+        }
+    }
+}
+
+void mySortBeta(QString &a, QString &b, QString &c) {
+    if (a > b ) {
+        if (c > a)      swap(a,b);
+        else if (b > c) swap(a,c);
+        else {
+            QString tmp = a;
+            a = b; b = c; c = tmp;
+        }
+    }
+    else {
+        if (a > c) {
+            QString tmp = c;
+            c = b;  b = a; a = tmp;
+        }
+        else if (b > c) swap(b,c);
+        else {
+            // they are already in order :-)
+        }
+    }
+}
+
+void mySortGamma(QString &a, QString &b, QString &c) {
+    if (a > b ) {
+        if (c > a)      swap(a,b);
+        else if (b > c) swap(a,c);
+        else {
+            QString tmp = a;
+            a = c; c = b; b = tmp;
+        }
+    }
+    else {
+        if (a > c) {
+            QString tmp = c;
+            c = b;  b = a; a = tmp;
+        }
+        else if (b > c) swap(b,c);
+        else {
+            // they are already in order :-)
+        }
+    }
+}
+
+void mySortDelta(QString &a, QString &b, QString &c) {
+    if (a < b ) {
+        if (c < a)      swap(a,b);
+        else if (b < c) swap(a,c);
+        else {
+            QString tmp = a;
+            a = b; b = c; c = tmp;
+        }
+    }
+    else {
+        if (a > c) {
+            QString tmp = c;
+            c = b;  b = a; a = tmp;
+        }
+        else if (b > c) swap(b,c);
+        else {
+            // they are already in order :-)
+        }
+    }
+}
+
+
+//This is the correct dice roller
+void MainWindow::diceAlpha(){
+    QString a, b;
+
+    //This loop is used to simulate the dice rolling by
+    //changing the images at a slowing down speed
+    for (int i = 0; i<=150000 ; i=i+5000){
+        usleep(i);
+
+        //First dice image. Since we want random pictures
+        //on each iteration, we get a random number, converted
+        //it to string and append it to others string that
+        //conform the names of the dices
+        a = ":/images/resources/d";
+        a.append(QString::number(rand()%6 + 1));
+        a.append(".png");
+
+        b = ":/images/resources/d";
+        b.append(QString::number(rand()%6 + 1));
+        b.append(".png");
+
+        //We load the images and check if there is no problem with them
+        if(!dice1.load(a) || !dice2.load(b)){
+            qDebug() << "Error2 Loading image";
+        }
+
+        //Finally we set the labels with the random dice images
+        label[3]->setPixmap(QPixmap::fromImage(dice1));
+        label[4]->setPixmap(QPixmap::fromImage(dice2));
+
+// Is there an option to see the changes of the dice/label
+// in this function and no just when we get out of it?
+
+//        Fail attempts
+//        layout->update();
+//        repaint();
+//        window->repaint();
+
+//        label[3]->repaint();
+//        label[3]->update();
+//        label[3]->hide();
+//        label[3]->show();
+//        label[3]->setVisible(false);
+//        label[3]->setVisible(true);
+
+//        layout->update();
+//        update();
+//        window->update();
+
+        window->hide();
+        window->show();
+    }
+
+    //Finally, we set the result of the sum of the dices.
+    QString a2 = (QString)a[20];
+    QString b2 = (QString)b[20];
+    int total = a2.toInt() + b2.toInt();
+    line[0]->setText(QString::number(total));
+}
+
+//This version sums the first dice twice
+void MainWindow::diceBeta(){
+    QString a, b;
+
+    for (int i = 0; i<=150000 ; i=i+5000){
+        usleep(i);
+
+        a = ":/images/resources/d";
+        a.append(QString::number(rand()%6 + 1));
+        a.append(".png");
+
+        b = ":/images/resources/d";
+        b.append(QString::number(rand()%6 + 1));
+        b.append(".png");
+
+        if(!dice1.load(a) || !dice2.load(b)){
+            qDebug() << "Error2 Loading image";
+        }
+
+        label[3]->setPixmap(QPixmap::fromImage(dice1));
+        label[4]->setPixmap(QPixmap::fromImage(dice2));
+
+// Is there an option to see the changes of the dice/label
+// in this function and no just when we get out of it?
+        window->hide();
+        window->show();
+    }
+
+    int total = a[20].digitValue() + a[20].digitValue();
+    line[0]->setText(QString::number(total));
+}
+
+//This one substracts the second dice to the first one
+void MainWindow::diceGamma(){
+    QString a, b;
+
+    for (int i = 0; i<=150000 ; i=i+5000){
+        usleep(i);
+
+        a = ":/images/resources/d";
+        a.append(QString::number(rand()%6 + 1));
+        a.append(".png");
+
+        b = ":/images/resources/d";
+        b.append(QString::number(rand()%6 + 1));
+        b.append(".png");
+
+        if(!dice1.load(a) || !dice2.load(b)){
+            qDebug() << "Error2 Loading image";
+        }
+
+        label[3]->setPixmap(QPixmap::fromImage(dice1));
+        label[4]->setPixmap(QPixmap::fromImage(dice2));
+
+// Is there an option to see the changes of the dice/label
+// in this function and no just when we get out of it?
+        window->hide();
+        window->show();
+    }
+
+    QString a2 = (QString)a[20];
+    QString b2 = (QString)b[20];
+    int total = a2.toInt() - b2.toInt();
+    line[0]->setText(QString::number(total));
+}
+
+//This one tooks the number 6 as a 12
+void MainWindow::diceDelta(){
+    QString a, b;
+
+    for (int i = 0; i<=150000 ; i=i+5000){
+        usleep(i);
+
+        a = ":/images/resources/d";
+        a.append(QString::number(rand()%6 + 1));
+        a.append(".png");
+
+        b = ":/images/resources/d";
+        b.append(QString::number(rand()%6 + 1));
+        b.append(".png");
+
+        if(!dice1.load(a) || !dice2.load(b)){
+            qDebug() << "Error2 Loading image";
+        }
+
+        label[3]->setPixmap(QPixmap::fromImage(dice1));
+        label[4]->setPixmap(QPixmap::fromImage(dice2));
+
+// Is there an option to see the changes of the dice/label
+// in this function and no just when we get out of it?
+        window->hide();
+        window->show();
+    }
+
+    int x, y;
+    QString a2 = (QString)a[20];
+    QString b2 = (QString)b[20];
+    if (a2.toInt() == 6){
+        x = 12;
+    }
+    else{
+        x = a2.toInt();
+    }
+    if (b2.toInt() == 6){
+        y = 12;
+    }
+    else{
+        y = b2.toInt();
+    }
+
+    int total = x + y;
+    line[0]->setText(QString::number(total));
+}
+
+// =========================================================
+// Rock Paper Scissor Functions
+// =========================================================
+
+
+///
+/// \brief RPSAlpha
+/// \param p1
+/// \param p2
+/// \param score1
+/// \param score2
+/// \return
+///
+
+int RPSAlpha(char p1, char p2, int &score1, int &score2) {
+    p1 = toupper(p1);
+    p2 = toupper(p2);
+    if ( p1 == 'P' ) {
+        if ( p2 == 'P' ) return 0;
+        else if (p2 == 'R') {
+            score1++; return 1;
+        }
+        else {
+            score2++; return 2;
+        }
+    }
+    else if (p1 == 'R') {
+        if ( p2 == 'R' ) return 0;
+        else if (p2 == 'S') {
+            score1++;    return 1;
+        }
+        else {
+            score2++;    return 2;
+        }
+    }
+    else {
+        if ( p2 == 'S' ) return 0;
+        else if (p2 == 'P') {
+            score1++;    return 1;
+        }
+        else {
+            score2++;    return 2;
+        }
+    }
+}
+
+
+///
+/// \brief RPSBeta
+/// \param p1
+/// \param p2
+/// \param score1
+/// \param score2
+/// \return
+///
+
+int RPSBeta(char p1, char p2, int &score1, int &score2) {
+    p1 = toupper(p1);
+    p2 = toupper(p2);
+    if ( p1 == 'P' ) {
+        if ( p2 == 'S' ) return 0;
+        else if (p2 == 'R') {
+            score1++; return 1;
+        }
+        else {
+            score2++; return 2;
+        }
+    }
+    else if (p1 == 'R') {
+        if ( p2 == 'S' ) return 0;
+        else if (p2 == 'P') {
+            score1++;    return 1;
+        }
+        else {
+            score2++;    return 2;
+        }
+    }
+    else {
+        if ( p2 == 'S' ) return 0;
+        else if (p2 == 'R') {
+            score1++;    return 1;
+        }
+        else {
+            score2++;    return 2;
+        }
+    }
+}
+
+
+///
+/// \brief RPSGamma
+/// \param p1
+/// \param p2
+/// \param score1
+/// \param score2
+/// \return
+///
+
+int RPSGamma(char p1, char p2, int &score1, int &score2) {
+    p1 = toupper(p1);
+    p2 = toupper(p2);
+    if ( p1 == 'P' ) {
+        if ( p2 == 'P' ) return 0;
+        else if (p2 == 'S') {
+            score1++; return 1;
+        }
+        else {
+            score2++; return 2;
+        }
+    }
+    else if (p1 == 'R') {
+        if ( p2 == 'R' ) return 0;
+        else if (p2 == 'P') {
+            score1++;    return 1;
+        }
+        else {
+            score2++;    return 2;
+        }
+    }
+    else {
+        if ( p2 == 'P' ) return 0;
+        else if (p2 == 'S') {
+            score1++;    return 1;
+        }
+        else {
+            score2++;    return 2;
+        }
+    }
+}
+
+///
+/// \brief RPSDelta
+/// \param p1
+/// \param p2
+/// \param score1
+/// \param score2
+/// \return
+///
+
+int RPSDelta(char p1, char p2, int &score1, int &score2) {
+    p1 = toupper(p1);
+    p2 = toupper(p2);
+    if ( p1 == 'P' ) {
+        if ( p2 == 'P' ) return 0;
+        else if (p2 == 'S') {
+            score2++; return 1;
+        }
+        else {
+            score1++; return 2;
+        }
+    }
+    else if (p1 == 'R') {
+        if ( p2 == 'R' ) return 0;
+        else if (p2 == 'P') {
+            score2++;    return 1;
+        }
+        else {
+            score1++;    return 2;
+        }
+    }
+    else {
+        if ( p2 == 'P' ) return 0;
+        else if (p2 == 'S') {
+            score2++;    return 1;
+        }
+        else {
+            score1++;    return 2;
+        }
+    }
+}
+
+// =========================================================
+// Check Words Functions
+// =========================================================
+
+
+
+QMap<int,QString> M;
+
+///
+/// \brief initCheckWMaps: initialize the values in the dictionary that is used throughout
+///                        the check functions.
+///
+
+void initCheckWMaps() {
+
+    M[1] = "one";       M[2] = "two";       M[3]  = "three";      M[4] = "four";
+    M[5]  = "five";     M[6] = "six";
+    M[7] = "seven";     M[8] = "eight";     M[9]  = "nine";       M[10] = "ten";
+    M[11] = "eleven";   M[12] = "twelve";   M[13] = "thirteen";   M[14] = "fourteen";
+    M[15] = "fifteen";  M[16] = "sixteen";  M[17] = "seventeen";  M[18] = "eighteen";
+    M[19] = "nineteen";
+    M[20] = "twenty";   M[30] = "thirty";   M[40] = "fourty";   M[50] = "fifty";
+    M[60] = "sixty";    M[70] = "seventy";  M[80] = "eighty";   M[90] = "ninety";
+}
+
+
+///
+/// \brief validateCheckQty: determines is entered text is a valid number in [0,999999999]
+/// \param st text entered by the user
+/// \param qty text converted to integer
+/// \return true if the entered text is valid
+///
+
+bool validateCheckQty(QString st, unsigned int &qty) {
+    int i = 0;
+    for (i = 0; i < st.length() ; i++) {
+        if (!st[i].isDigit()) return false;
+    }
+
+    if (i > 9) return false;
+
+    qty = st.toInt();
+    return true;
+}
+
+///
+/// \brief wordForNumber: Given a number n in [0,999] returns the word equivalent
+/// \param n: the number
+/// \return a Qstring containing the number in words
+///
+
+QString wordForNumber(int n) {
+    QString st;
+
+    int tens = n % 100;
+    if (tens == 0)
+        st = "";
+    else if (tens <= 20)
+        st = M[n];
+    else {
+        st = M[10 * (tens/10)];
+        if (tens % 10)
+            st.append(" "  + M[tens % 10]);
+    }
+
+    n = n / 100;
+    if (n) st.prepend(M[n % 10] + " hundred" + (st.length() > 0 ? " " : ""));
+
+    return st;
+}
+
+
+///
+/// \brief checkWAlpha: One of the functions to convert a number in [0,999999999] to words
+/// \param n: the number
+/// \return a Qstring containing the number in words
+///
+
+QString checkWAlpha(int n) {
+    QString st;
+
+    // the cents
+    st = wordForNumber(n % 1000);
+
+    // the thousands
+    n = n / 1000;
+    if (n % 1000) st.prepend( wordForNumber(n % 1000) + " thousand" +  (st.length() > 0 ? " " : ""));
+
+    // the millions
+    n = n / 1000;
+    if (n % 1000) st.prepend( wordForNumber(n % 1000) + " million" +  (st.length() > 0 ? " " : ""));
+
+    return st;
+}
+
+///
+/// \brief checkWBeta: One of the functions to convert a number in [0,999999999] to words
+/// \param n: the number
+/// \return a Qstring containing the number in words
+///
+
+QString checkWBeta(int n) {
+    QString st;
+
+    st = wordForNumber(n % 1000);
+    n = n / 1000;
+    if (n % 1000) st.append( wordForNumber(n % 1000) + " thousand" +  (st.length() > 0 ? " " : ""));
+    n = n / 1000;
+    if (n % 1000) st.append( wordForNumber(n % 1000) + " million" +  (st.length() > 0 ? " " : ""));
+
+    return st;
+}
+
+///
+/// \brief checkWGamma: One of the functions to convert a number in [0,999999999] to words
+/// \param n: the number
+/// \return a Qstring containing the number in words
+///
+
+QString checkWGamma(int n) {
+    QString st;
+
+    st = wordForNumber(n % 10);
+    n = n / 1000;
+    if (n % 1000) st.append( wordForNumber(n % 10) + " thousand" +  (st.length() > 0 ? " " : ""));
+    n = n / 1000;
+    if (n % 1000) st.append( wordForNumber(n % 10) + " million" +  (st.length() > 0 ? " " : ""));
+
+    return st;
+}
+
+///
+/// \brief checkWDelta: One of the functions to convert a number in [0,999999999] to words
+/// \param n: the number
+/// \return a Qstring containing the number in words
+///
+
+
+QString checkWDelta(int n) {
+    QString st;
+
+    n /= 10;
+    st = wordForNumber(n % 1000);
+    n = n / 1000;
+    if (n % 1000) st.prepend( wordForNumber(n % 1000) + " thousand" +  (st.length() > 0 ? " " : ""));
+    n = n / 1000;
+    if (n % 1000) st.prepend( wordForNumber(n % 1000) + " million" +  (st.length() > 0 ? " " : ""));
+
+    return st;
+}
+
+
+// =========================================================
+// Zulu Functions
+// =========================================================
+
+
+bool validZuluTime(const QString &time, const QString &zone, int &hours, int &minutes) {
+    int i = 0;
+    for (i = 0; i< time.size(); i++)
+        if (!time[i].isDigit()) return false;
+
+    if (i != 4) return false;
+    hours   = time.mid(0,2).toInt();
+    minutes = time.mid(2,2).toInt();
+
+    if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59)
+        return false;
+
+    if (zone.length() < 1 || !zone[0].isLetter()  || toupper(zone.toStdString()[0]) ==  'J') return false;
+    return true;
+}
+
+//This is the correct one
+
+QString zuluAlpha(int hours, int minutes, char zone) {
+    int diff = 0;
+
+    if (zone <= 'I')         diff = zone - 'A' + 1;
+    else if (zone <= 'M')    diff = 10 + (zone - 'K');
+    else if (zone <= 'Y')    diff = -(zone - 'N' + 1);
+    else                     diff = 0;
+
+    hours = (hours + (24 + diff) ) % 24;
+
+    return QString::number(hours) + QString::number(minutes);
+}
+
+QString zuluBeta(int hours, int minutes, char zone) {
+    int diff = 0;
+
+    if (zone <= 'I')         diff = zone - 'B' + 1;
+    else if (zone <= 'M')    diff = 10 + (zone - 'M');
+    else if (zone <= 'Y')    diff = -(zone - 'N');
+    diff = 0;
+
+    hours = (hours + (24 + diff) ) % 24;
+
+    return QString::number(hours)  + QString::number(minutes);
+}
+
+QString zuluGamma(int hours, int minutes, char zone) {
+    int diff = 0;
+
+    if (zone <= 'I')          diff = zone - 'A' + 1;
+    else if (zone <= 'M')     diff = 10 + (zone - 'M');
+    else if (zone <= 'Y')     diff = -(zone - 'N');
+    else                      diff = 0;
+
+    hours = (hours + (24 - diff) ) % 24;
+
+    return QString::number(hours) + QString::number(minutes);
+}
+
+QString zuluDelta(int hours, int minutes, char zone) {
+    int diff = 0;
+
+    if (zone <= 'M')        diff = zone - 'B' + 1;
+    else if (zone <= 'Y')   diff = -(zone - 'N');
+    else                    diff = 0;
+
+    hours = (hours + (24 - diff) ) % 24;
+
+    return QString::number(hours)  + QString::number(minutes);
+}
+
+
+
+// =========================================================
+// APFT Functions
+// =========================================================
+
+
+//This it the correct one
+
+void MainWindow::APFTAlpha(){
+    //For each one of these variables we apply the formula that they use
+    //to set the points
+    double sit_ups = qFloor(line[0]->text().toDouble() * 1.6 - 24.8);
+
+    double push_ups = qFloor(line[1]->text().toInt() * 1.42);
+
+    double running_time = qFloor((line[2]->text().left(2).append('.' + line[2]->text().right(2))).toDouble());
+    double two_mile_run = qFloor((820 / 3) - ((40 * running_time) / 3));
+
+    //Since the maximum of points that one can obtain
+    //on each excercise type is 100, we restrict it
+    if (sit_ups > 100){
+        sit_ups = 100;
+    }
+    else if (sit_ups < 0){
+        sit_ups = 0;
+    }
+    if (push_ups > 100){
+        push_ups = 100;
+    }
+    else if (push_ups < 0){
+        push_ups = 0;
+    }
+    if (two_mile_run > 100){
+        two_mile_run = 100;
+    }
+    else if (two_mile_run < 0){
+        two_mile_run = 0;
+    }
+
+    //Finally we set the outputs.
+    line[3]->setText(QString::number(sit_ups));
+    line[4]->setText(QString::number(push_ups));
+    line[5]->setText(QString::number(two_mile_run));
+    line[6]->setText(QString::number(push_ups + sit_ups + two_mile_run));
+    if (push_ups >= 60 && sit_ups >= 60 && two_mile_run >= 60){
+        label[7]->setText("PASS");
+    }
+    else{
+        label[7]->setText("FAIL");
+    }
+}
+
+//This one do not check if the number is greater than 100
+
+void MainWindow::APFTBeta(){
+    double sit_ups = qFloor(line[0]->text().toDouble() * 1.6 - 24.8);
+
+    double push_ups = qFloor(line[1]->text().toInt() * 1.42);
+
+    double running_time = qFloor((line[2]->text().left(2).append('.' + line[2]->text().right(2))).toDouble());
+    double two_mile_run = qFloor((820 / 3) - ((40 * running_time) / 3));
+
+    line[3]->setText(QString::number(sit_ups));
+    line[4]->setText(QString::number(push_ups));
+    line[5]->setText(QString::number(two_mile_run));
+    line[6]->setText(QString::number(push_ups + sit_ups + two_mile_run));
+    if (push_ups >= 60 && sit_ups >= 60 && two_mile_run >= 60){
+        line[7]->setText("PASS");
+    }
+    else{
+        line[7]->setText("FAIL");
+    }
+}
+
+//This one switch the results
+
+void MainWindow::APFTGamma(){
+    double sit_ups = qFloor(line[0]->text().toDouble() * 1.6 - 24.8);
+    double push_ups = qFloor(line[1]->text().toInt() * 1.42);
+    double running_time = qFloor((line[2]->text().left(2).append('.' + line[2]->text().right(2))).toDouble());
+    double two_mile_run = qFloor((820 / 3) - ((40 * running_time) / 3));
+
+    if (sit_ups > 100){
+        sit_ups = 100;
+    }
+    else if (sit_ups < 0){
+        sit_ups = 0;
+    }
+    if (push_ups > 100){
+        push_ups = 100;
+    }
+    else if (push_ups < 0){
+        push_ups = 0;
+    }
+    if (two_mile_run > 100){
+        two_mile_run = 100;
+    }
+    else if (two_mile_run < 0){
+        two_mile_run = 0;
+    }
+
+    line[5]->setText(QString::number(sit_ups));
+    line[3]->setText(QString::number(push_ups));
+    line[4]->setText(QString::number(two_mile_run));
+    line[6]->setText(QString::number(push_ups + sit_ups + two_mile_run));
+    if (push_ups >= 60 && sit_ups >= 60 && two_mile_run >= 60){
+        line[7]->setText("PASS");
+    }
+    else{
+        line[7]->setText("FAIL");
+    }
+}
+
+//This one do not sums the points but the quantities of each excercise
+
+void MainWindow::APFTDelta(){
+    double sit_ups = qFloor(line[0]->text().toDouble() * 1.6 - 24.8);
+    double push_ups = qFloor(line[1]->text().toInt() * 1.42);
+    double running_time = qFloor((line[2]->text().left(2).append('.'
+                                   + line[2]->text().right(2))).toDouble());
+    double two_mile_run = qFloor((820 / 3) - ((40 * running_time) / 3));
+
+    if (sit_ups > 100){
+        sit_ups = 100;
+    }
+    else if (sit_ups < 0){
+        sit_ups = 0;
+    }
+    if (push_ups > 100){
+        push_ups = 100;
+    }
+    else if (push_ups < 0){
+        push_ups = 0;
+    }
+    if (two_mile_run > 100){
+        two_mile_run = 100;
+    }
+    else if (two_mile_run < 0){
+        two_mile_run = 0;
+    }
+
+    int sumaTo = line[0]->text().toInt() + line[1]->text().toInt() + running_time;
+    line[3]->setText(QString::number(sit_ups));
+    line[4]->setText(QString::number(push_ups));
+    line[5]->setText(QString::number(two_mile_run));
+    line[6]->setText(QString::number(sumaTo));
+    if (push_ups >= 60 && sit_ups >= 60 && two_mile_run >= 60){
+        line[7]->setText("PASS");
+    }
+    else{
+        line[7]->setText("FAIL");
+    }
+}
+
+
+

functions.h

@@ -0,0 +1,31 @@
+#ifndef FUNCTIONS_H
+#define FUNCTIONS_H
+
+#include <string>
+using namespace std;
+
+bool validateSorts(const QString &a, const QString &b, const QString &c);
+void mySortAlpha(QString &a, QString &b, QString &c);
+void mySortBeta(QString &a, QString &b, QString &c);
+void mySortGamma(QString &a, QString &b, QString &c);
+void mySortDelta(QString &a, QString &b, QString &c);
+
+bool validZuluTime(const QString &time, const QString &zone, int &hours, int &minutes);
+QString zuluAlpha(int hours, int minutes, char zone);
+QString zuluBeta(int hours, int minutes, char zone);
+QString zuluGamma(int hours, int minutes, char zone);
+QString zuluDelta(int hours, int minutes, char zone);
+
+int RPSAlpha(char p1, char p2, int &score1, int &score2);
+int RPSBeta(char p1, char p2, int &score1, int &score2);
+int RPSGamma(char p1, char p2, int &score1, int &score2);
+int RPSDelta(char p1, char p2, int &score1, int &score2);
+
+void initCheckWMaps();
+bool validateCheckQty(QString st, unsigned int &qty);
+QString checkWAlpha(int n);
+QString checkWBeta(int n);
+QString checkWGamma(int n);
+QString checkWDelta(int n);
+
+#endif // FUNCTIONS_H

labTesting.md

@@ -0,0 +1,66 @@
+# Testing and Unit Testing
+
+##Objectives
+
+Throughout this exercise the students will practice:
+
+* Testing various versions of a program to validate their operation
+* Unit Testing
+
+## Concepts
+
+As you have learned in previous labs, getting a program to compile is only a minor part of programming. It is super important to test functions in order to validate that they produce the correct results.
+
+
+### Exercise 1
+
+This exercise is an adaptation of [1]. You are provided with a program that implements several versions of five simple functions, e.g. rock-paper-scisors, sorting 3 numbers. By testing the versions, you and your partner will determine which of the versions is correctly implemented.   
+
+This exercise requires **NO programming**, just testing. 
+
+The functions implemented in the program are:
+
+* **3 Sorts**: a program that receives three strings and sorts them in lexicographical order. For example, given `jirafa`, `zorra`, and `coqui`. Will sort them as: `coqui`, `jirafa`, and `zorra`.
+
+* **Dice**: when the user presses the `Roll them` button, the program will generate two random numbers between 1 and 6.  The sum of the random numbers is reported. 
+
+* **Rock, Papers, Scissors**: The user enters the play for the two players ( 'R' for Rock, 'P' for Paper and 'S' for Scissors) and specifies the number of games needed to win the tournament. The program then reports who won and the score. The program reports if a player wins the tournament.
+
+* **Check Writer**: The user enters a number between 0 and 999,999,999 (inclusive). The program's output is a long string version of the number. For example, if the user inputs '654123' the program will output 'six hundred fifty four thousand one hundred twenty three'.
+
+* **Zulu time**: given the time in zulu time (Greenwich Mean Time) and the military zone that the user whishes to know, the program outputs the time at that zone. The format for the input is `####` in 23 hour format, e.g. 2212. The list of valid military zones is given in http://en.wikipedia.org/wiki/List_of_military_time_zones. Examples of correct output:
+    * Given 1230 and zone A, the output would be 1330
+    * Given 1230 and zone N, the output would be 1130
+
+Step 1: 
+Download the program from $XYZ$.
+
+Step 2:
+Run the program. For each of the functions, test all the versions and determine which is the valid one. Report which is the correct version in every method. Also, explain the tests that you performed that allowed you to determine that the other versions are incorrect. 
+
+
+### Exercise 2
+
+Running tests "by hand" each time that you run a program gets tiresome very quickly. You and your partner have done it for a few simple functions. Imagine doing the same for full-blown program!, such as a browser or word processor.
+
+Unit tests help programmers produce valid code and ease the process of debugging while avoiding the tedious task of entering tests by hand on each execution.
+
+
+Step 1: 
+Download the proyect from $XYZ$. The proyect contains only one source code file `main.cpp`. This file contains four functions whose results are only partially correct. Your task is to write unit tests for each them to identify their wrong results. 
+
+A unit test function `test_fact()` is provided for the function `fact`. If you invoke this function from `main` and compile and run the program. You will get the following message:
+
+```cpp
+Assertion failed: (fact(2) == 2), function test_fact, file ../UnitTests/main.cpp, line 69.
+``` 
+
+This would be enough for us to claim that function `fact` is not correctly implemented. Comment the invocation of `test_fact()` from main.
+
+Step 2:
+Write unit tests for the rest of the functions. Remember that you must call each of the unit test functions from the `main` for them to run. Copy each of the functions in the provided sheet.
+
+
+### References
+
+[1] http://nifty.stanford.edu/2005/TestMe/

main.cpp

@@ -0,0 +1,69 @@
+#include <QApplication>
+#include "mainwindow.h"
+#include <cstdlib>
+#include <ctime>
+#include "functions.h"
+#include <cassert>
+#include <QDebug>
+
+void testSort() {
+    QString a = "AAA" , b = "BBB" , c = "CCC";
+    mySortBeta(a,b,c);
+    assert( a < b && b < c);
+
+    a = "AAA", b = "CCC", c = "BBB";
+    mySortBeta(a,b,c);
+    assert( a < b && b < c);
+
+    a = "BBB", b = "AAA", c = "CCC";
+    mySortBeta(a,b,c);
+    assert( a < b && b < c);
+
+    a = "BBB", b = "CCC", c = "AAA";
+    mySortBeta(a,b,c);
+    assert( a < b && b < c);
+
+    a = "CCC", b = "AAA", c = "BBB";
+    mySortBeta(a,b,c);
+    //qDebug() << a << b << c;
+    assert( a < b && b < c);
+
+    a = "CCC", b = "BBB", c = "AAA";
+    mySortBeta(a,b,c);
+    assert( a < b && b < c);
+
+    qDebug() << "Passed Test for Sort!!!!";
+}
+
+void testCheck() {
+
+    assert( checkWAlpha(91) == QString("ninety one"));
+    assert( checkWAlpha(891) == QString("eight hundred ninety one"));
+    assert( checkWAlpha(100) == QString("one hundred"));
+    assert( checkWAlpha(59123) == QString("fifty nine thousand one hundred twenty three"));
+    assert( checkWAlpha(100001) == QString("one hundred thousand one"));
+    assert( checkWAlpha(100000) == QString("one hundred thousand"));
+    assert( checkWAlpha(100000000) == QString("one hundred million"));
+    qDebug() << "Passed Test for Check Word!!!!";
+}
+
+int main(int argc, char *argv[])
+{
+//    testSort();
+    initCheckWMaps(); /*** DONT FORGET ***/
+
+//    testCheck();
+//    qDebug() << checkWAlpha(91);
+//    qDebug() << checkWAlpha(891);
+//    qDebug() << checkWAlpha(801);
+
+
+    srand(time(NULL));
+    QApplication a(argc, argv);
+    MainWindow w;
+    w.show();
+
+
+
+    return a.exec();
+}

mainwindow.cpp

@@ -0,0 +1,818 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+#include "secondwindow.cpp"
+
+#include <QDebug>
+#include <QtCore/qmath.h>
+#include <QMessageBox>
+#include "functions.h"
+
+MainWindow::MainWindow(QWidget *parent) :
+    QMainWindow(parent),
+    ui(new Ui::MainWindow)
+{
+    ui->setupUi(this);
+
+    //These are the size of the arrays of widgets 'line-edit',
+    //'label' and 'button'
+    buttonSize = 2;
+    lineSize = 7;
+    labelSize = 8;
+
+    // We set every pointer member to point NULL because we
+    // when we delete every pointer we dont want to delete a
+    // pointer that was already deleted in other moment or
+    // was never used
+    layout = NULL;
+    for (int i = 0; i<buttonSize ; i++){
+        button[i] = 0;
+    }
+    for (int i = 0; i < lineSize ; i++){
+        line[i] = 0;
+    }
+    for (int i = 0; i<labelSize ; i++){
+        label[i] = 0;
+    }
+
+    window = new secondwindow;
+
+    // We need to know whenever the second window is closed to show the
+    // main window, or to hide when the second one is showed
+    connect(window, SIGNAL(cerrado(bool)), this, SLOT(mostrar(bool)));
+
+    if(!dice1.load(":/images/resources/d1.png") || !dice2.load(":/images/resources/d1.png")){
+        qDebug() << "Error1 Loading image";
+    }
+
+    initCheckWMaps();
+}
+
+MainWindow::~MainWindow()
+{
+    delete ui;
+}
+
+//This function show the main window and delete all the items created on the closed one or hide the mainwindow
+void MainWindow::mostrar(bool si){
+    if (si==true){
+        show();
+
+        // Deleting pointers and point them to NULL
+        for (int i = 0; i<buttonSize ; i++){
+            delete button[i];
+            button[i] = NULL;
+        }
+        for (int i = 0; i<lineSize ; i++){
+            delete line[i];
+            line[i] = NULL;
+        }
+        for (int i = 0; i<labelSize ; i++){
+            delete label[i];
+            label[i] = NULL;
+        }
+        delete layout;
+        layout = NULL;
+        delete window;
+
+        // Create the new window and connecting it again with the signal
+        window = new secondwindow;
+        connect(window, SIGNAL(cerrado(bool)), this, SLOT(mostrar(bool)));
+    }
+    else hide();
+}
+
+//It is a slot that reads what item of the combo box was selected and save it
+//into a member
+void MainWindow::whatOption(QString str){
+    option = str;
+}
+
+//Clear all the lines that are used
+void MainWindow::clearLines(){
+    for (int i = 0; i < lineSize; i++){
+        if (line[i] != NULL){
+            line[i]->clear();
+        }
+    }
+    score1 = score2 = 0;
+}
+
+//It forces the input 1 to be valid
+void MainWindow::RPSnormalizer1(QString str){
+    //For every character in the string only allow
+    //the character 'R' for rock, 'P' for paper and
+    //'S' for scissors. Delete all the other characters
+    //different from this three, and if is 'r', 'p' or 's'
+    //make it uppercase.
+    for (int i = 0; i< str.size(); i++){
+        if      (str[i] == 'r'){
+            str[i] = 'R';
+        }
+        else if (str[i] == 'p'){
+            str[i] = 'P';
+        }
+        else if (str[i] == 's'){
+            str[i] = 'S';
+        }
+
+        else if (str[i] == 'R' || str[i] == 'P' ||
+                 str[i] == 'S');//then its ok, do nothing
+        else{
+            str = str.mid(0,i).append(str.mid(i+1));
+        }
+    }
+
+    line[0]->setText(str);
+}
+
+//It forces the input 2 to be valid
+void MainWindow::RPSnormalizer2(QString str){
+    for (int i = 0; i< str.size(); i++){
+        if      (str[i] == 'r'){
+            str[i] = 'R';
+        }
+        else if (str[i] == 'p'){
+            str[i] = 'P';
+        }
+        else if (str[i] == 's'){
+            str[i] = 'S';
+        }
+        else if (str[i] == 'R' || str[i] == 'P' ||
+                 str[i] == 'S');//then its ok, do nothing
+        else{
+            str = str.mid(0,i).append(str.mid(i+1));
+        }
+    }
+
+    line[1]->setText(str);
+}
+
+//It forces the input 3 to be valid
+void MainWindow::RPSnormalizer3(QString str){
+    //Verify that the string do not contains other thing than
+    //numbers
+    for (int i = 0; i< str.size(); i++){
+        if (!str[i].isDigit()){
+            str = str.mid(0,i).append(str.mid(i+1));
+        }
+    }
+
+    //Left zeros do not count, delete them
+    while (str[0] == '0'){
+        str = str.mid(1);
+    }
+
+    //If the player exagerates the number of games to win
+    //change the string to the maximum number allowed
+    if (str.toInt() > 150){
+        str = "150";
+    }
+
+    line[2]->setText(str);
+}
+
+//It forces the input to be valid
+void MainWindow::CheckWnormalizer(QString str){
+    //Just allow numbers
+    for (int i = 0; i< str.size(); i++){
+        if (!str[i].isDigit()){
+            str = str.mid(0,i).append(str.mid(i+1));
+        }
+    }
+
+    //Zeros on the left side do not count (delete them)
+    while (str[0] == '0'){
+        str = str.mid(1);
+    }
+
+    //The maximum is 999,999,999
+    if (str.toDouble() > 999999999){
+        str = "999999999";
+    }
+
+    line[0]->setText(str);
+}
+
+
+
+//It forces the first input of Zulu to be valid
+void MainWindow::Zulunormalizer1(QString str){
+    //Just allow numbers to be written
+    for (int i = 0; i< str.size(); i++){
+        if (!str[i].isDigit()){
+            str = str.mid(0,i).append(str.mid(i+1));
+        }
+    }
+
+    //The maximum here is 2359, so force it to be the
+    //maximum when the user write a larger number
+    if (str.toInt() > 2359){
+        str = "2359";
+    }
+
+    line[0]->setText(str);
+}
+
+//It forces the second input of Zulu to be valid
+void MainWindow::Zulunormalizer2(QString str){
+    //Just allow one character to be written
+    if (str.size() > 1){
+        str = str[1];
+    }
+
+    //If that only character is 'e', 'c', 'm' or 'p'
+    //the uppercase it
+    if (str[0] == 'e' || str[0] == 'c' ||
+            str[0] == 'm' || str[0] == 'p'){
+        str = str[0].toUpper();
+    }
+    //If we get here is because the character is not
+    //the lowercase letters allowed... so if they are
+    //not the uppercase letters that we admit we have
+    //to delete it.
+    else if (str[0] != 'E' || str[0] != 'C' ||
+             str[0] != 'M' || str[0] != 'P'){
+        str = "";
+    }
+
+    line[1]->setText(str);
+}
+
+//It forces the first input of APFT to be valid
+void MainWindow::APFTnormalizer1(QString str){
+    //Just admit numbers, delete the other type of
+    //characters
+    for (int i = 0; i< str.size(); i++){
+        if (!str[i].isDigit()){
+            str = str.mid(0,i).append(str.mid(i+1));
+        }
+    }
+
+    //Left zeros are not valid
+    while (str[0] == '0'){
+        str = str.mid(1);
+    }
+
+    line[0]->setText(str);
+}
+
+//It forces the second input of APFT to be valid
+void MainWindow::APFTnormalizer2(QString str){
+    //Just allow the numbers to be written
+    for (int i = 0; i< str.size(); i++){
+        if (!str[i].isDigit()){
+            str = str.mid(0,i).append(str.mid(i+1));
+        }
+    }
+
+    //Left-hand zeros? Delete them
+    while (str[0] == '0'){
+        str = str.mid(1);
+    }
+
+    line[1]->setText(str);
+}
+
+//It forces the third input of APFT to be valid
+void MainWindow::APFTnormalizer3(QString str){
+    //Allow just numbers on the string only if the
+    //character is not in the position 2
+    for (int i = 0; i< str.size(); i++){
+        if (!str[i].isDigit() && i != 2){
+            str = str.mid(0,i).append(str.mid(i+1));
+        }
+    }
+
+    //Then if there is a character in the position 2
+    //and it is not ':', then add it between the
+    //position 1 and 3
+    if (str.size() > 2 && str[2] != ':'){
+        while (str.size()>2 && !str[2].isDigit()){
+            str = str.mid(0,2).append(str.mid(3));
+        }
+        str = str.mid(0, 2).append(':').append(str.mid(2));
+    }
+    //If the size exceeds 5, then take the first five
+    //so then we will have the format mm:ss
+    if (str.size() > 5){
+        str = str.mid(0, 5);
+    }
+
+    line[2]->setText(str);
+}
+
+//Checks which version of sort is selected and call it
+void MainWindow::sorts(){
+    QString a = line[0]->text();
+    QString b = line[1]->text();
+    QString c = line[2]->text();
+
+    if (!validateSorts(a,b,c)) {
+        QMessageBox::warning(this, "Alert",
+             "Please provide the three non-empty strings");
+        return;
+    }
+
+    if (option == "Version Alpha"){
+        mySortAlpha(a,b,c);
+    }
+    else if (option == "Version Beta"){
+        mySortBeta(a,b,c);
+    }
+    else if (option == "Version Gamma"){
+        mySortGamma(a,b,c);
+    }
+    else{
+        mySortDelta(a,b,c);
+    }
+    line[3]->setText(a);
+    line[4]->setText(b);
+    line[5]->setText(c);
+}
+
+
+
+
+//Checks which version of RPS is selected and call it
+void MainWindow::RPSs(){
+
+    QString p1 = line[0]->text();
+    QString p2 = line[1]->text();
+    QString gamesToWin = line[2]->text();
+
+    if (p1.length() * p2.length() * gamesToWin.length() == 0) {
+        QMessageBox::warning(this, "Alert",
+                             "Please provide a play for both players and the number of games to win");
+        return;
+    }
+
+    int winnerNum;
+    if (option == "Version Alpha")
+        winnerNum = RPSAlpha(p1.toStdString()[0], p2.toStdString()[0], score1, score2);
+    else if (option == "Version Beta")
+        winnerNum = RPSBeta(p1.toStdString()[0], p2.toStdString()[0], score1, score2);
+    else if (option == "Version Gamma")
+        winnerNum = RPSGamma(p1.toStdString()[0], p2.toStdString()[0], score1, score2);
+    else
+        winnerNum = RPSDelta(p1.toStdString()[0], p2.toStdString()[0], score1, score2);
+
+    QString st;
+
+    switch(winnerNum) {
+    case 1:  st = "Player 1"; break;
+    case 2:  st = "Player 2"; break;
+    case 0:  st = "Tie"; break;
+    default: st = "Error";
+    }
+
+    line[3]->setText(st);
+
+    line[4]->setText(QString::number(score1) + " to " + QString::number(score2));
+
+    if (score1 == gamesToWin.toInt() || score2 == gamesToWin.toInt() ) {
+        QMessageBox::warning(this, "Alert",
+                             "Game won by " + st + "!!!");
+        score1 = score2 = 0;
+    }
+
+}
+
+//Checks which version of dice is selected and call it
+void MainWindow::dices(){
+    if (option == "Version Alpha")
+        diceAlpha();
+    else if (option == "Version Beta")
+        diceBeta();
+    else if (option == "Version Gamma")
+        diceGamma();
+    else
+        diceDelta();
+}
+
+
+//Checks which version of check-writer is selected and call it
+void MainWindow::checkWs(){
+    unsigned int qty;
+    if (!validateCheckQty(line[0]->text(),qty)) {
+        QMessageBox::warning(this, "Alert",
+                             "Enter a valid amount!");
+    }
+
+    if (option == "Version Alpha")
+        line[1]->setText( checkWAlpha(qty) );
+    else if (option == "Version Beta")
+        line[1]->setText( checkWBeta(qty) );
+    else if (option == "Version Gamma")
+        line[1]->setText( checkWGamma(qty) );
+    else
+        line[1]->setText( checkWDelta(qty) );
+}
+
+//Checks which version of zulu is selected and call it
+void MainWindow::zulus(){
+    QString zuluTime = line[0]->text();
+    QString zuluZone = line[1]->text();
+    int hours, minutes;
+
+    if (!validZuluTime(zuluTime, zuluZone, hours, minutes) ) {
+
+        QMessageBox::warning(this, "Alert",
+                             "Either Zulu Time or Zone is not valid");
+        line[2]->setText("Error");
+        return;
+    }
+    if (option == "Version Alpha")
+        line[2]->setText( zuluAlpha(hours, minutes, zuluZone.toStdString()[0]) );
+    else if (option == "Version Beta")
+        line[2]->setText( zuluBeta(hours, minutes, zuluZone.toStdString()[0]) );
+    else if (option == "Version Gamma")
+        line[2]->setText( zuluGamma(hours, minutes, zuluZone.toStdString()[0]) );
+    else
+        line[2]->setText( zuluDelta(hours, minutes, zuluZone.toStdString()[0]) );
+
+}
+
+//Checks which version of APFT is selected and call it
+void MainWindow::APFTs(){
+    if (option == "Version Alpha"){
+        APFTAlpha();
+    }
+    else if (option == "Version Beta"){
+        APFTBeta();
+    }
+    else if (option == "Version Gamma"){
+        APFTGamma();
+    }
+    else{
+        APFTDelta();
+    }
+}
+
+//Here is what happend when Sort-button is clicked
+void MainWindow::on_SortsButton_clicked()
+{
+    //Create a new QComboBox and add the items in it
+    method = new QComboBox;
+    method->addItem("Version Alpha");
+    method->addItem("Version Beta");
+    method->addItem("Version Gamma");
+    method->addItem("Version Delta");
+    option = "Version Alpha"; //Default option is alpha
+
+    //We create a new layout and insert the comboBox to it
+    layout = new QGridLayout;
+    layout->addWidget(method, 0, 0, 1, -1);
+
+    //The buttons needed are sort and clear so we create them
+    button[0] = new QPushButton("Sort");
+    button[1] = new QPushButton("Clear");
+
+    //3 lines for input and 3 for output
+    for (int i = 0; i<6 ; i++){
+        line[i] = new QLineEdit;
+    }
+
+    //The user is not able to write on the output lines
+    line[3]->setEnabled(false);
+    line[4]->setEnabled(false);
+    line[5]->setEnabled(false);
+
+    //Labels to let the user understand the app
+    label[0] = new QLabel("Input");
+    label[1] = new QLabel("Output");
+
+    //Here we insert the widgets on the layout
+    layout->addWidget(label[0], 1, 0);
+    layout->addWidget(label[1], 1, 2);
+    layout->addWidget(line[0], 2, 0);
+    layout->addWidget(line[1], 3, 0);
+    layout->addWidget(line[2], 4, 0);
+    layout->addWidget(button[0], 1, 1, 2, 1);
+    layout->addWidget(button[1], 3, 1, 2, 1);
+    layout->addWidget(line[3], 2, 2);
+    layout->addWidget(line[4], 3, 2);
+    layout->addWidget(line[5], 4, 2);
+
+    //Here we connect the signals of the widgets generated
+    //by code to their respective functions
+    connect(method, SIGNAL(currentIndexChanged(QString)), this, SLOT(whatOption(QString)));
+    connect(button[0], SIGNAL(clicked()), this, SLOT(sorts()));
+    connect(button[1], SIGNAL(clicked()), this, SLOT(clearLines()));
+
+    //Now that we have set our new window, we hide the main-window
+    //and show the new one. The new-window has a signal that
+    //notify when it was closed so we can shor the main-window
+    window->setLayout(layout);
+    mostrar(false);
+    window->show();
+}
+
+//Here is what happend when Dice-button is clicked
+void MainWindow::on_DiceButton_clicked()
+{
+    //Create a new QComboBox and add the items in it
+    method = new QComboBox;
+    method->addItem("Version Alpha");
+    method->addItem("Version Beta");
+    method->addItem("Version Gamma");
+    method->addItem("Version Delta");
+    option = "Version Alpha"; //Default option is alpha
+
+    //We create a new layout and insert the comboBox to it
+    layout = new QGridLayout;
+    layout->addWidget(method, 0, 0, 1, -1);
+
+    //Labels to let the user understand the app
+    label[0] = new QLabel("Dice 1");
+    label[1] = new QLabel("Dice 2");
+    label[2] = new QLabel("Total");
+
+    //The user is not able to write on the output line
+    line[0] = new QLineEdit;
+    line[0]->setEnabled(false);
+
+    //Here we just need one button to roll the dices
+    button[0] = new QPushButton("Roll them!");
+
+    //Labels to put the dices' images on them
+    label[3] = new QLabel;
+    label[4] = new QLabel;
+    label[3]->setPixmap(QPixmap::fromImage(dice1));
+    label[4]->setPixmap(QPixmap::fromImage(dice2));
+
+    //Here we insert the widgets on the layout
+    layout->addWidget(label[0], 1, 0);
+    layout->addWidget(label[3], 1, 1);
+    layout->addWidget(label[1], 2, 0);
+    layout->addWidget(label[4], 2, 1);
+    layout->addWidget(label[2], 3, 0);
+    layout->addWidget(line[0], 3, 1);
+    layout->addWidget(button[0], 1, 2, 2, 1);
+
+    //Here we connect the signals of the widgets generated
+    //by code to their respective functions
+    connect(method, SIGNAL(currentIndexChanged(QString)), this, SLOT(whatOption(QString)));
+    connect(button[0], SIGNAL(clicked()), this, SLOT(dices()));
+
+    //Now that we have set our new window, we hide the main-window
+    //and show the new one. The new-window has a signal that
+    //notify when it was closed so we can shor the main-window
+    window->setLayout(layout);
+    mostrar(false);
+    window->show();
+}
+
+//Here is what happend when RPS-button is clicked
+void MainWindow::on_RPSButton_clicked()
+{
+    //Create a new QComboBox and add the items in it
+    method = new QComboBox;
+    method->addItem("Version Alpha");
+    method->addItem("Version Beta");
+    method->addItem("Version Gamma");
+    method->addItem("Version Delta");
+    option = "Version Alpha"; //Default option is alpha
+
+    //We create a new layout and insert the comboBox to it
+    layout = new QGridLayout;
+    layout->addWidget(method, 0, 0, 1, -1);
+
+    //The buttons needed here are the 'play' and 'clear' buttons
+    button[0] = new QPushButton("Play");
+    button[1] = new QPushButton("Clear");
+
+    //3 inputs and 1 output
+    for (int i = 0; i<4; i++){
+        line[i] = new QLineEdit;
+    }
+
+    //The user is not able to write on the output line
+    line[3]->setEnabled(false);
+
+    //Labels to let the user understand the app
+    label[0] = new QLabel("Player 1's moves");
+    label[1] = new QLabel("Player 2's moves");
+    label[2] = new QLabel("How many games to win:");
+    label[3] = new QLabel("Winner:");
+    label[4] = new QLabel("Tournament:");
+    //lines for score
+    line[4] = new QLineEdit;
+    line[4]->setEnabled(false);
+
+    //Here we insert the widgets on the layout
+    layout->addWidget(label[0], 1, 0);
+    layout->addWidget(line[0], 2, 0);
+    layout->addWidget(label[1], 3, 0);
+    layout->addWidget(line[1], 4, 0);
+    layout->addWidget(label[2], 5, 0);
+    layout->addWidget(line[2], 5, 1);
+    layout->addWidget(label[3], 6, 0);
+    layout->addWidget(line[3], 6, 1);
+    layout->addWidget(button[0], 2, 1);
+    layout->addWidget(button[1], 3, 1);
+    layout->addWidget(line[4],7 ,1 );
+    layout->addWidget(label[4],7 ,0 );
+
+    //Here we connect the signals of the widgets generated
+    //by code to their respective functions
+    connect(method, SIGNAL(currentIndexChanged(QString)), this, SLOT(whatOption(QString)));
+    connect(button[0], SIGNAL(clicked()), this, SLOT(RPSs()));
+    connect(button[1], SIGNAL(clicked()), this, SLOT(clearLines()));
+    connect(line[0], SIGNAL(textEdited(QString)), this, SLOT(RPSnormalizer1(QString)));
+    connect(line[1], SIGNAL(textEdited(QString)), this, SLOT(RPSnormalizer2(QString)));
+    connect(line[2], SIGNAL(textEdited(QString)), this, SLOT(RPSnormalizer3(QString)));
+
+    //Now that we have set our new window, we hide the main-window
+    //and show the new one. The new-window has a signal that
+    //notify when it was closed so we can shor the main-window
+    window->setLayout(layout);
+    mostrar(false);
+    window->show();
+    score1 = score2 = 0;
+}
+
+//Here is what happend when CheckWritter-button is clicked
+void MainWindow::on_CheckWriterButton_clicked()
+{
+    //Create a new QComboBox and add the items in it
+    method = new QComboBox;
+    method->addItem("Version Alpha");
+    method->addItem("Version Beta");
+    method->addItem("Version Gamma");
+    method->addItem("Version Delta");
+    option = "Version Alpha"; //Default option is alpha
+
+    //We create a new layout and insert the comboBox to it
+    layout = new QGridLayout;
+    layout->addWidget(method, 0, 0, 1, -1);
+
+    //Label to let the user understand the app
+    label[0] = new QLabel("Number to convert");
+
+    //We just need two buttons to clear or convert
+    button[0] = new QPushButton("Convert");
+    button[1] = new QPushButton("Clear");
+
+    //1 output and 1 input
+    for (int i = 0; i<2; i++){
+        line[i] = new QLineEdit;
+    }
+
+    //The user is not able to write on the output line
+    line[1]->setEnabled(false);
+
+    //Here we insert the widgets on the layout
+    layout->addWidget(label[0], 1, 0, 1, 2);
+    layout->addWidget(line[0], 2, 0, 1, 2);
+    layout->addWidget(button[0], 3, 0);
+    layout->addWidget(button[1], 3, 1);
+    layout->addWidget(line[1], 4, 0, 1, 2);
+
+    //Here we connect the signals of the widgets generated
+    //by code to their respective functions
+    connect(method, SIGNAL(currentIndexChanged(QString)), this, SLOT(whatOption(QString)));
+    connect(button[0], SIGNAL(clicked()), this, SLOT(checkWs()));
+    connect(button[1], SIGNAL(clicked()), this, SLOT(clearLines()));
+    //connect(line[0], SIGNAL(textEdited(QString)), this, SLOT(CheckWnormalizer(QString)));
+
+    //Now that we have set our new window, we hide the main-window
+    //and show the new one. The new-window has a signal that
+    //notify when it was closed so we can shor the main-window
+    window->setLayout(layout);
+    mostrar(false);
+    window->show();
+}
+
+//Here is what happend when Zulu-button is clicked
+void MainWindow::on_ZuluButton_clicked()
+{
+    //Create a new QComboBox and add the items in it
+    method = new QComboBox;
+    method->addItem("Version Alpha");
+    method->addItem("Version Beta");
+    method->addItem("Version Gamma");
+    method->addItem("Version Delta");
+    option = "Version Alpha"; //Default option is alpha
+
+    //We create a new layout and insert the comboBox to it
+    layout = new QGridLayout;
+    layout->addWidget(method, 0, 0, 1, -1);
+
+    //Labels to let the user understand the app
+    label[0] = new QLabel("Zulu time:");
+    label[1] = new QLabel("Standard time");
+
+    //Just the buttons to clear and convert the time
+    button[0] = new QPushButton("Clear");
+    button[1] = new QPushButton("Convert");
+
+    //2 inputs and 1 output
+    for (int i = 0; i<3; i++){
+        line[i] = new QLineEdit;
+    }
+
+    //The user is not able to write on the output line
+    line[2]->setEnabled(false);
+
+    //Here we insert the widgets on the layout
+    layout->addWidget(label[0], 1, 0);
+    layout->addWidget(line[0], 2, 0);
+    layout->addWidget(line[1], 2, 1);
+    layout->addWidget(button[0], 3, 0);
+    layout->addWidget(button[1], 3, 1);
+    layout->addWidget(label[1], 4, 0);
+    layout->addWidget(line[2], 4, 1);
+
+    //Here we connect the signals of the widgets generated
+    //by code to their respective functions
+    connect(method, SIGNAL(currentIndexChanged(QString)), this, SLOT(whatOption(QString)));
+    connect(button[0], SIGNAL(clicked()), this, SLOT(clearLines()));
+    connect(button[1], SIGNAL(clicked()), this, SLOT(zulus()));
+
+    // Rafa 2014-09-16 - Validation will be done when button is clicked
+    //    connect(line[0], SIGNAL(textEdited(QString)), this, SLOT(Zulunormalizer1(QString)));
+    //    connect(line[1], SIGNAL(textEdited(QString)), this, SLOT(Zulunormalizer2(QString)));
+
+    //Now that we have set our new window, we hide the main-window
+    //and show the new one. The new-window has a signal that
+    //notify when it was closed so we can shor the main-window
+    window->setLayout(layout);
+    mostrar(false);
+    window->show();
+}
+
+//Here is what happend when APFT-button is clicked
+void MainWindow::on_APFTButton_clicked()
+{
+    //Create a new QComboBox and add the items in it
+    method = new QComboBox;
+    method->addItem("Version Alpha");
+    method->addItem("Version Beta");
+    method->addItem("Version Gamma");
+    method->addItem("Version Delta");
+    option = "Version Alpha"; //Default option is alpha
+
+    //We create a new layout and insert the comboBox to it
+    layout = new QGridLayout;
+    layout->addWidget(method, 0, 0, 1, -1);
+
+    //3 inputs and 4 outputs
+    for (int i = 0; i<7; i++){
+        line[i] = new QLineEdit;
+    }
+
+    //The user is not able to write on the output lines
+    line[3]->setEnabled(false);
+    line[4]->setEnabled(false);
+    line[5]->setEnabled(false);
+    line[6]->setEnabled(false);
+
+    //Labels to let the user understand the app
+    label[0] = new QLabel("Sit-Ups");
+    label[1] = new QLabel("Push-Ups");
+    label[2] = new QLabel("2 Mile Run");
+    label[3] = new QLabel("Sit-Ups Score");
+    label[4] = new QLabel("Push-Ups Score");
+    label[5] = new QLabel("2 Mile Run Score");
+    label[6] = new QLabel("Total Score");
+    label[7] = new QLabel("----");
+
+    //Just the buttons to calculate it and clear the lines
+    button[0] = new QPushButton("Calculate");
+    button[1] = new QPushButton("Clear");
+
+    //Here we insert the widgets on the layout
+    layout->addWidget(label[0], 1, 0);
+    layout->addWidget(label[1], 2, 0);
+    layout->addWidget(label[2], 3, 0);
+    layout->addWidget(button[0], 4, 0);
+    layout->addWidget(line[0], 1, 1);
+    layout->addWidget(line[1], 2, 1);
+    layout->addWidget(line[2], 3, 1);
+    layout->addWidget(button[1], 4, 1);
+    layout->addWidget(label[3], 1, 2);
+    layout->addWidget(label[4], 2, 2);
+    layout->addWidget(label[5], 3, 2);
+    layout->addWidget(label[6], 4, 2);
+    layout->addWidget(line[3], 1, 3);
+    layout->addWidget(line[4], 2, 3);
+    layout->addWidget(line[5], 3, 3);
+    layout->addWidget(line[6], 4, 3);
+    layout->addWidget(label[7], 4, 4);
+
+    //Here we connect the signals of the widgets generated
+    //by code to their respective functions
+    connect(method, SIGNAL(currentIndexChanged(QString)), this, SLOT(whatOption(QString)));
+    connect(button[0], SIGNAL(clicked()), this, SLOT(APFTs()));
+    connect(button[1], SIGNAL(clicked()), this, SLOT(clearLines()));
+    connect(line[0], SIGNAL(textEdited(QString)), this, SLOT(APFTnormalizer1(QString)));
+    connect(line[1], SIGNAL(textEdited(QString)), this, SLOT(APFTnormalizer2(QString)));
+    connect(line[2], SIGNAL(textEdited(QString)), this, SLOT(APFTnormalizer3(QString)));
+
+    //Now that we have set our new window, we hide the main-window
+    //and show the new one. The new-window has a signal that
+    //notify when it was closed so we can shor the main-window
+    window->setLayout(layout);
+    mostrar(false);
+    window->show();
+}

mainwindow.h

@@ -0,0 +1,99 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QtGui>
+#include "secondwindow.h"
+
+#include <QGridLayout>
+#include <QPushButton>
+#include <QLineEdit>
+#include <QLabel>
+#include <QComboBox>
+#include <QString>
+#include <QImage>
+
+namespace Ui {
+    class MainWindow;
+}
+
+class MainWindow : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    explicit MainWindow(QWidget *parent = 0);
+    ~MainWindow();
+
+    void diceAlpha();
+    void diceBeta();
+    void diceGamma();
+    void diceDelta();
+
+    void APFTAlpha();
+    void APFTBeta();
+    void APFTGamma();
+    void APFTDelta();
+
+private slots:
+    void on_SortsButton_clicked();
+    void on_DiceButton_clicked();
+    void on_RPSButton_clicked();
+    void on_CheckWriterButton_clicked();
+    void on_ZuluButton_clicked();
+    void on_APFTButton_clicked();
+
+    void mostrar(bool si);
+
+    void whatOption(QString str);
+
+    void clearLines();
+
+    void RPSnormalizer1(QString str);
+
+    void RPSnormalizer2(QString str);
+
+    void RPSnormalizer3(QString str);
+
+    void CheckWnormalizer(QString str);
+
+    void Zulunormalizer1(QString str);
+
+    void Zulunormalizer2(QString str);
+
+    void APFTnormalizer1(QString str);
+
+    void APFTnormalizer2(QString str);
+
+    void APFTnormalizer3(QString str);
+
+    void sorts();
+
+    void RPSs();
+
+    void dices();
+
+    void checkWs();
+
+    void zulus();
+
+    void APFTs();
+
+private:
+    Ui::MainWindow *ui;
+    secondwindow *window;
+    QGridLayout *layout;
+    QPushButton *button[2];
+    int buttonSize;
+    QLineEdit *line[7];
+    int lineSize;
+    QLabel *label[7];
+    int labelSize;
+    QComboBox *method;
+    QString option;
+    QImage dice1;
+    QImage dice2;
+    int score1, score2;
+};
+
+#endif // MAINWINDOW_H

mainwindow.ui

@@ -0,0 +1,193 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>487</width>
+    <height>257</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>361</width>
+    <height>202</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralWidget">
+   <widget class="QPushButton" name="SortsButton">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>70</y>
+      <width>141</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>3 Sorts</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="RPSButton">
+    <property name="geometry">
+     <rect>
+      <x>330</x>
+      <y>70</y>
+      <width>141</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Rock, Paper, 
+ Scissors</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="DiceButton">
+    <property name="geometry">
+     <rect>
+      <x>170</x>
+      <y>70</y>
+      <width>141</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Dice</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="APFTButton">
+    <property name="geometry">
+     <rect>
+      <x>330</x>
+      <y>140</y>
+      <width>141</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>APFT</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="ZuluButton">
+    <property name="geometry">
+     <rect>
+      <x>170</x>
+      <y>140</y>
+      <width>141</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Zulu</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="CheckWriterButton">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>140</y>
+      <width>141</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Check Writer</string>
+    </property>
+   </widget>
+   <widget class="QFrame" name="frame">
+    <property name="geometry">
+     <rect>
+      <x>-30</x>
+      <y>0</y>
+      <width>581</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="styleSheet">
+     <string notr="true">background-color: gray;</string>
+    </property>
+    <property name="frameShape">
+     <enum>QFrame::StyledPanel</enum>
+    </property>
+    <property name="frameShadow">
+     <enum>QFrame::Raised</enum>
+    </property>
+    <widget class="QLabel" name="label">
+     <property name="geometry">
+      <rect>
+       <x>180</x>
+       <y>10</y>
+       <width>161</width>
+       <height>41</height>
+      </rect>
+     </property>
+     <property name="font">
+      <font>
+       <pointsize>23</pointsize>
+      </font>
+     </property>
+     <property name="styleSheet">
+      <string notr="true">color:white;</string>
+     </property>
+     <property name="text">
+      <string>Testing Lab</string>
+     </property>
+    </widget>
+    <widget class="QFrame" name="frame_2">
+     <property name="geometry">
+      <rect>
+       <x>30</x>
+       <y>54</y>
+       <width>641</width>
+       <height>4</height>
+      </rect>
+     </property>
+     <property name="styleSheet">
+      <string notr="true">background-color:red</string>
+     </property>
+     <property name="frameShape">
+      <enum>QFrame::StyledPanel</enum>
+     </property>
+     <property name="frameShadow">
+      <enum>QFrame::Raised</enum>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QFrame" name="frame_3">
+    <property name="geometry">
+     <rect>
+      <x>290</x>
+      <y>200</y>
+      <width>201</width>
+      <height>61</height>
+     </rect>
+    </property>
+    <property name="styleSheet">
+     <string notr="true">background-image: url(/home/rgb/Desktop/eip/CaesarCipher/logo.png);
+border: 0px;
+repeat: no-repeat;</string>
+    </property>
+    <property name="frameShape">
+     <enum>QFrame::StyledPanel</enum>
+    </property>
+    <property name="frameShadow">
+     <enum>QFrame::Raised</enum>
+    </property>
+   </widget>
+  </widget>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources/>
+ <connections/>
+</ui>

secondwindow.cpp

@@ -0,0 +1,11 @@
+#include "secondwindow.h"
+
+secondwindow::secondwindow(QWidget *parent) :
+    QWidget(parent)
+{
+
+}
+
+void secondwindow::closeEvent(QCloseEvent *){
+    emit cerrado(true);
+}

secondwindow.h

@@ -0,0 +1,22 @@
+#ifndef SECONDWINDOW_H
+#define SECONDWINDOW_H
+
+#include <QWidget>
+
+class secondwindow : public QWidget
+{
+    Q_OBJECT
+public:
+    explicit secondwindow(QWidget *parent = 0);
+
+signals:
+    void cerrado(bool si);
+
+protected:
+    virtual void closeEvent(QCloseEvent *);
+
+public slots:
+
+};
+
+#endif // SECONDWINDOW_H