fuckyou2

/**
 * @file   aufgabe1-bit.c
 * @brief  Aufgabe1 - Bit Manipulationen
 */

#include <stdio.h>
// Falls notwendig erweitern Sie die Liste der includes


/**
 @brief Aufgabe1a: Vertauschen von Bytes
 @param [in] short int i
 @return short int

 Schreiben Sie eine Funktion die das Low Byte (Bits 0-7) und
 das High Byte (Bits 8-15) vertauscht.
 Z.B. aus der Zahl 0x4020 wird die Zahl 0x2040.
 */

unsigned short int switchLowHighByte(short int i) {
    unsigned short int lowByte = i & 0x00FF;
    unsigned short int highByte = i & 0xFF00;

    highByte = highByte >> 8;
    lowByte = lowByte << 8;

    return (unsigned short int)lowByte + (unsigned short int)highByte;

}


typedef enum {
    Stop = 0,
    Start = 1,
    Finish = 5,
    Fail = 255
} Status;


typedef enum {
    One = 1,
    Fifteen = 15,
    Sixteen = 16,
    Last = 255
} Numbers;

/**
 @brief Aufgabe1b: Serialisierung von Datenstrukturen
 @param [in] Status s
 @param [in] Numbers n
 @param [out] short int* data

 Gegeben sind zwei enums. Ihre Aufgabe ist es jeweils Werte der
 beiden enums in ein Datenpacket der Groesse 16Bit zu packen (serialisieren).
 Werte des enums Status sollen dabei in das Low Byte und Werte
 des enums Numbers sollen in das High Byte gepackt werden.
 */


void serialize(Status s, Numbers n, short int* data) {
    *data = ((unsigned short int)n<<8)+(unsigned short int)s;
}

/**
 @brief Aufgabe1c: Deserialisierung von Datenstrukturen
 @param [in] short int data
 @param [out] Status* s
 @param [out] Numbers* n

 Schreiben Sie eine Funktion die Werte der enums Status und Number
 aus einem 16Bit Wert entpackt (deserialisiert).
 Wir nehmen an, dass die enum Werte mittels der serialize Funktion
 verpackt wurden.
 */

void deserialize(short int data, Status* s, Numbers* n) {
    *s = (Status)(data & 0x00FF);
    *n = (Numbers)((data & 0xFF00) >> 8);
}

/*
 Testfunktionen
 */
enum TestEnum {
    OK = 255,
    FAIL = 0
};
typedef enum TestEnum Test;

Test testLowHigh() {
    Test t = FAIL;
    unsigned short int tests[] = {0x0000, 0xff00, 0x2040, 0x4020};
    unsigned short int expectations[] = {0x0000, 0x00ff, 0x4020, 0x2040};
    for(int i = 0; i < 4; i++){
        if((switchLowHighByte(tests[i]) == expectations[i]))
            t = OK;
        else
            t = FAIL;
        }
    return t;
}

Test testSerialize(Status s, Numbers n, short int* data, short int expected){
    Test t = FAIL;
    serialize(s, n, data);

    unsigned short int[5] sTests = {0x0000, 0x0001, 0x0005, 0x00ff};
    unsigned short int[5] nTests = {0x0001, 0x0005, 0x0010, 0x0};

    for(int i = 0; i < 4; i++){
        if (*data == expected) {
            t = OK;
        }else{
            t = FAIL;
        }
    }
    return t;
}

Test testDeserialize(short int data, Status* s, Numbers* n,Status newS, Numbers newN){
    Test t;
    deserialize(data, s, n);
    if (*s == newS && *n == newN) {
        t = OK;
    }else{
        t = FAIL;
    }
    return t;
}

int main() {
    // Test Aufgabe A
    if(testLowHighByte() == OK){
        printf("Alle Tests OK !");
    } else {
        printf("FAIL");
    }

    // Test Aufgabe B
    short int dataTestB = 0;
    printf("%x \n", testSerialize(0, 1, &dataTestB, 0x0100));

    // Test Aufgabe C
    short int dataTestC = 0x0100;
    Status s;
    Numbers n;
    printf("%x \n", testDeserialize(dataTestC, &s, &n, 0x00, 0x01));
}