info2Praktikum-NeuronalesNetz/imageInputTests.c

#include "imageInput.h"
#include "unity.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* ---------------------------------------------------------
   Hilfsfunktion: Testdatei vorbereiten
   --------------------------------------------------------- */
static void prepareImageFile(const char *path, unsigned int width,
                             unsigned int height, unsigned int numberOfImages,
                             unsigned char label) {
  FILE *file = fopen(path, "wb");
  if (!file)
    return;

  // Header
  const char *fileTag = "__info2_image_file_format__";
  fwrite(fileTag, 1, strlen(fileTag), file);

  // Meta-Daten als unsigned short
  unsigned short n = (unsigned short)numberOfImages;
  unsigned short w = (unsigned short)width;
  unsigned short h = (unsigned short)height;
  fwrite(&n, sizeof(unsigned short), 1, file);
  fwrite(&w, sizeof(unsigned short), 1, file);
  fwrite(&h, sizeof(unsigned short), 1, file);

  // Pixelbuffer
  GrayScalePixelType *buffer =
      calloc(width * height, sizeof(GrayScalePixelType));
  if (!buffer) {
    fclose(file);
    return;
  }
  for (unsigned int i = 0; i < width * height; i++)
    buffer[i] = (GrayScalePixelType)i;

  // Jedes Bild schreiben: Pixel + Label
  for (unsigned int img = 0; img < numberOfImages; img++) {
    fwrite(buffer, sizeof(GrayScalePixelType), width * height, file);
    fwrite(&label, sizeof(unsigned char), 1, file);
  }

  free(buffer);
  fclose(file);
}

/* ---------------------------------------------------------
   Unit Tests
   --------------------------------------------------------- */

void test_readImagesReturnsCorrectNumberOfImages(void) {
  GrayScaleImageSeries *series = NULL;
  const unsigned int expectedNumberOfImages = 2;
  const char *path = "testFile.info2";
  prepareImageFile(path, 8, 8, expectedNumberOfImages, 1);
  series = readImages(path);
  TEST_ASSERT_NOT_NULL(series);
  TEST_ASSERT_EQUAL_UINT(expectedNumberOfImages, series->count);
  clearSeries(series);
  remove(path);
}

void test_readImagesReturnsCorrectImageWidth(void) {
  GrayScaleImageSeries *series = NULL;
  const unsigned int expectedWidth = 10;
  const char *path = "testFile.info2";
  prepareImageFile(path, expectedWidth, 8, 2, 1);
  series = readImages(path);
  TEST_ASSERT_NOT_NULL(series);
  TEST_ASSERT_NOT_NULL(series->images);
  TEST_ASSERT_EQUAL_UINT(2, series->count);
  TEST_ASSERT_EQUAL_UINT(expectedWidth, series->images[0].width);
  TEST_ASSERT_EQUAL_UINT(expectedWidth, series->images[1].width);
  clearSeries(series);
  remove(path);
}

void test_readImagesReturnsCorrectImageHeight(void) {
  GrayScaleImageSeries *series = NULL;
  const unsigned int expectedHeight = 10;
  const char *path = "testFile.info2";
  prepareImageFile(path, 8, expectedHeight, 2, 1);
  series = readImages(path);
  TEST_ASSERT_NOT_NULL(series);
  TEST_ASSERT_NOT_NULL(series->images);
  TEST_ASSERT_EQUAL_UINT(2, series->count);
  TEST_ASSERT_EQUAL_UINT(expectedHeight, series->images[0].height);
  TEST_ASSERT_EQUAL_UINT(expectedHeight, series->images[1].height);
  clearSeries(series);
  remove(path);
}

void test_readImagesReturnsCorrectLabels(void) {
  const unsigned char expectedLabel = 15;

  GrayScaleImageSeries *series = NULL;
  const char *path = "testFile.info2";
  prepareImageFile(path, 8, 8, 2, expectedLabel);
  series = readImages(path);
  TEST_ASSERT_NOT_NULL(series);
  TEST_ASSERT_NOT_NULL(series->labels);
  TEST_ASSERT_EQUAL_UINT(2, series->count);
  for (int i = 0; i < 2; i++) {
    TEST_ASSERT_EQUAL_UINT8(expectedLabel, series->labels[i]);
  }
  clearSeries(series);
  remove(path);
}

void test_readImagesReturnsNullOnNotExistingPath(void) {
  const char *path = "testFile.txt";
  remove(path);
  TEST_ASSERT_NULL(readImages(path));
}

void test_readImagesFailsOnWrongFileTag(void) {
  const char *path = "testFile.info2";
  FILE *file = fopen(path, "w");
  if (file != NULL) {
    fprintf(file, "some_tag                  ");
    fclose(file);
    TEST_ASSERT_NULL(readImages(path));
  }
  remove(path);
}

void test_read_GrayScale_Pixel(void) {
  GrayScaleImageSeries *series = NULL;
  const char *path = "testFile.info2";

  prepareImageFile(path, 8, 8, 1, 1);
  series = readImages(path);

  TEST_ASSERT_NOT_NULL(series);
  TEST_ASSERT_NOT_NULL(series->images);
  TEST_ASSERT_EQUAL_UINT(1, series->count);

  for (int i = 0; i < (8 * 8); i++) {
    TEST_ASSERT_EQUAL_UINT8((GrayScalePixelType)i, series->images[0].buffer[i]);
  }

  clearSeries(series);
  remove(path);
}

/* ---------------------------------------------------------
   Optional: Mehrere Bilder gleichzeitig testen
   --------------------------------------------------------- */

void test_readImagesMultipleImagesContent(void) {
  GrayScaleImageSeries *series = NULL;
  const char *path = "testFile.info2";
  const unsigned int numberOfImages = 3;
  const unsigned int width = 4;
  const unsigned int height = 4;
  const unsigned char label = 7;

  prepareImageFile(path, width, height, numberOfImages, label);

  series = readImages(path);
  TEST_ASSERT_NOT_NULL(series);
  TEST_ASSERT_NOT_NULL(series->images);
  TEST_ASSERT_NOT_NULL(series->labels);
  TEST_ASSERT_EQUAL_UINT(numberOfImages, series->count);

  for (unsigned int img = 0; img < numberOfImages; img++) {
    for (unsigned int i = 0; i < width * height; i++)
      TEST_ASSERT_EQUAL_UINT8((GrayScalePixelType)i,
                              series->images[img].buffer[i]);
    TEST_ASSERT_EQUAL_UINT8(label, series->labels[img]);
  }

  clearSeries(series);
  remove(path);
}

/* ---------------------------------------------------------
   Setup / Teardown
   --------------------------------------------------------- */
void setUp(void) {}
void tearDown(void) {}

/* ---------------------------------------------------------
   main()
   --------------------------------------------------------- */
int main(void) {
  UNITY_BEGIN();

  printf("\n============================\nImage input "
         "tests\n============================\n");

  RUN_TEST(test_readImagesReturnsCorrectNumberOfImages);
  RUN_TEST(test_readImagesReturnsCorrectImageWidth);
  RUN_TEST(test_readImagesReturnsCorrectImageHeight);
  RUN_TEST(test_readImagesReturnsCorrectLabels);
  RUN_TEST(test_readImagesReturnsNullOnNotExistingPath);
  RUN_TEST(test_readImagesFailsOnWrongFileTag);
  RUN_TEST(test_read_GrayScale_Pixel);
  RUN_TEST(test_readImagesMultipleImagesContent);

  return UNITY_END();
}