numbersFinal
This commit is contained in:
parent
19b9fec1bf
commit
b7882d9e71
33
numbers.c
33
numbers.c
@ -28,18 +28,21 @@ unsigned int *createNumbers(unsigned int len)
|
||||
{
|
||||
srand(time(NULL));
|
||||
|
||||
TreeNode *numbers;
|
||||
|
||||
int isDuplicate = 0;
|
||||
unsigned int number = rand() % (2 * len) + 1;
|
||||
unsigned int *array = malloc(len * sizeof(int));
|
||||
unsigned int *array = malloc(len * sizeof(unsigned int));
|
||||
if (array == NULL)
|
||||
return NULL;
|
||||
|
||||
numbers = addToTree(NULL, &number, sizeof(int), compareFct, &isDuplicate);
|
||||
TreeNode* numbers = addToTree(NULL, &number, sizeof(unsigned int), compareFct, &isDuplicate);
|
||||
array[0] = number;
|
||||
for (int i = 1; i < len; i++)
|
||||
|
||||
for (unsigned int i = 1; i < len; i++)
|
||||
{
|
||||
number = rand() % (2 * len) + 1;
|
||||
numbers = addToTree(numbers, &number, sizeof(int), compareFct, &isDuplicate);
|
||||
|
||||
numbers = addToTree(numbers, &number, sizeof(unsigned int), compareFct, &isDuplicate);
|
||||
|
||||
if (isDuplicate == 1)
|
||||
{
|
||||
isDuplicate = 0;
|
||||
@ -69,22 +72,28 @@ unsigned int *createNumbers(unsigned int len)
|
||||
// Returns only the only number in numbers which is present twice. Returns zero on errors.
|
||||
unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
|
||||
{
|
||||
unsigned int *copyNumbers = malloc(sizeof(int) * len);
|
||||
for (int i = 0; i < len; i++)
|
||||
unsigned int *copyNumbers = malloc(sizeof(unsigned int) * len);
|
||||
if (copyNumbers == NULL)
|
||||
return 0;
|
||||
|
||||
unsigned int duplicateValue = 0;
|
||||
|
||||
for (unsigned int i = 0; i < len; i++)
|
||||
{
|
||||
copyNumbers[i] = numbers [i];
|
||||
}
|
||||
|
||||
qsort(copyNumbers, len, sizeof(int), compareFct);
|
||||
qsort(copyNumbers, len, sizeof(unsigned int), compareFct);
|
||||
|
||||
for (int i = 0; i < len - 1; i++)
|
||||
for (unsigned int i = 0; i < len - 1; i++)
|
||||
{
|
||||
if (copyNumbers[i] == copyNumbers[i + 1])
|
||||
{
|
||||
return copyNumbers[i];
|
||||
duplicateValue = copyNumbers[i];
|
||||
free(copyNumbers);
|
||||
return duplicateValue;
|
||||
}
|
||||
}
|
||||
|
||||
free(copyNumbers);
|
||||
return 0;
|
||||
}
|
||||
197
test_numbers.c
Normal file
197
test_numbers.c
Normal file
@ -0,0 +1,197 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "matrix.h"
|
||||
#include "unity.h"
|
||||
|
||||
|
||||
void test_createMatrixFailsOnZeroDimensions(void)
|
||||
{
|
||||
Matrix matrixToTest1 = createMatrix(0, 1);
|
||||
Matrix matrixToTest2 = createMatrix(1, 0);
|
||||
TEST_ASSERT_NULL(matrixToTest1.buffer);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, matrixToTest1.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, matrixToTest1.cols);
|
||||
TEST_ASSERT_NULL(matrixToTest2.buffer);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, matrixToTest2.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, matrixToTest2.cols);
|
||||
}
|
||||
|
||||
void test_createMatrixReturnsCorrectMatrixDimensions(void)
|
||||
{
|
||||
const unsigned int expectedRows = 15;
|
||||
const unsigned int expectedCols = 10;
|
||||
|
||||
Matrix matrixToTest = createMatrix(expectedRows, expectedCols);
|
||||
TEST_ASSERT_EQUAL_UINT32(expectedRows, matrixToTest.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(expectedCols, matrixToTest.cols);
|
||||
free(matrixToTest.buffer);
|
||||
}
|
||||
|
||||
void test_clearMatrixSetsMembersToNull(void)
|
||||
{
|
||||
Matrix matrixToTest = createMatrix(10, 10);
|
||||
clearMatrix(&matrixToTest);
|
||||
TEST_ASSERT_NULL(matrixToTest.buffer);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, matrixToTest.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, matrixToTest.cols);
|
||||
}
|
||||
|
||||
void test_addReturnsCorrectResult(void)
|
||||
{
|
||||
MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
|
||||
MatrixType buffer2[] = {7, 8, 9, 10, 11, 12};
|
||||
Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
|
||||
Matrix matrix2 = {.rows=2, .cols=3, .buffer=buffer2};
|
||||
|
||||
Matrix result = add(matrix1, matrix2);
|
||||
|
||||
float expectedResults[] = {8, 10, 12, 14, 16, 18};
|
||||
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix2.rows, result.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result.cols);
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix2.cols, result.cols);
|
||||
TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result.rows * result.cols);
|
||||
TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result.buffer, result.cols * result.rows);
|
||||
free(result.buffer);
|
||||
}
|
||||
|
||||
void test_addFailsOnDifferentInputDimensions(void)
|
||||
{
|
||||
MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
|
||||
MatrixType buffer2[] = {7, 8, 9, 10, 11, 12};
|
||||
Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
|
||||
Matrix matrix2 = {.rows=3, .cols=2, .buffer=buffer2};
|
||||
|
||||
Matrix result = add(matrix1, matrix2);
|
||||
|
||||
TEST_ASSERT_NULL(result.buffer);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, result.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, result.cols);
|
||||
}
|
||||
|
||||
void test_addSupportsBroadcasting(void)
|
||||
{
|
||||
MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
|
||||
MatrixType buffer2[] = {7, 8};
|
||||
Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
|
||||
Matrix matrix2 = {.rows=2, .cols=1, .buffer=buffer2};
|
||||
|
||||
Matrix result1 = add(matrix1, matrix2);
|
||||
Matrix result2 = add(matrix2, matrix1);
|
||||
|
||||
float expectedResults[] = {8, 9, 10, 12, 13, 14};
|
||||
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result1.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result1.cols);
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result2.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result2.cols);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result1.rows * result1.cols);
|
||||
TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result1.buffer, result1.cols * result1.rows);
|
||||
TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result2.rows * result2.cols);
|
||||
TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result2.buffer, result2.cols * result2.rows);
|
||||
|
||||
free(result1.buffer);
|
||||
free(result2.buffer);
|
||||
}
|
||||
|
||||
void test_multiplyReturnsCorrectResults(void)
|
||||
{
|
||||
MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
|
||||
MatrixType buffer2[] = {7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
|
||||
Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
|
||||
Matrix matrix2 = {.rows=3, .cols=4, .buffer=buffer2};
|
||||
|
||||
Matrix result = multiply(matrix1, matrix2);
|
||||
|
||||
float expectedResults[] = {74, 80, 86, 92, 173, 188, 203, 218};
|
||||
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(matrix2.cols, result.cols);
|
||||
TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result.rows * result.cols);
|
||||
TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result.buffer, result.cols * result.rows);
|
||||
|
||||
free(result.buffer);
|
||||
}
|
||||
|
||||
void test_multiplyFailsOnWrongInputDimensions(void)
|
||||
{
|
||||
MatrixType buffer1[] = {1, 2, 3, 4, 5, 6};
|
||||
MatrixType buffer2[] = {7, 8, 9, 10, 11, 12};
|
||||
Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1};
|
||||
Matrix matrix2 = {.rows=2, .cols=3, .buffer=buffer2};
|
||||
|
||||
Matrix result = multiply(matrix1, matrix2);
|
||||
|
||||
TEST_ASSERT_NULL(result.buffer);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, result.rows);
|
||||
TEST_ASSERT_EQUAL_UINT32(0, result.cols);
|
||||
}
|
||||
|
||||
void test_getMatrixAtReturnsCorrectResult(void)
|
||||
{
|
||||
MatrixType buffer[] = {1, 2, 3, 4, 5, 6};
|
||||
Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer};
|
||||
int expectedResult = buffer[4];
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(expectedResult, getMatrixAt(matrixToTest, 1, 1));
|
||||
}
|
||||
|
||||
void test_getMatrixAtFailsOnIndicesOutOfRange(void)
|
||||
{
|
||||
MatrixType buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer};
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(UNDEFINED_MATRIX_VALUE, getMatrixAt(matrixToTest, 2, 3));
|
||||
}
|
||||
|
||||
void test_setMatrixAtSetsCorrectValue(void)
|
||||
{
|
||||
const int expectedResult = -1;
|
||||
MatrixType buffer[] = {1, 2, 3, 4, 5, 6};
|
||||
Matrix matrixUnderTest = {.rows=2, .cols=3, .buffer=buffer};
|
||||
|
||||
setMatrixAt(expectedResult, matrixUnderTest, 1, 2);
|
||||
TEST_ASSERT_EQUAL_INT(expectedResult, buffer[5]);
|
||||
}
|
||||
|
||||
void test_setMatrixAtFailsOnIndicesOutOfRange(void)
|
||||
{
|
||||
const float expectedResults[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
MatrixType buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer};
|
||||
|
||||
setMatrixAt(-1, matrixToTest, 2, 3);
|
||||
TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, matrixToTest.buffer, sizeof(buffer)/sizeof(MatrixType));
|
||||
}
|
||||
|
||||
void setUp(void) {
|
||||
// Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
|
||||
}
|
||||
|
||||
void tearDown(void) {
|
||||
// Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
UNITY_BEGIN();
|
||||
|
||||
printf("============================\nMatrix tests\n============================\n");
|
||||
RUN_TEST(test_createMatrixReturnsCorrectMatrixDimensions);
|
||||
RUN_TEST(test_createMatrixFailsOnZeroDimensions);
|
||||
RUN_TEST(test_clearMatrixSetsMembersToNull);
|
||||
RUN_TEST(test_addReturnsCorrectResult);
|
||||
RUN_TEST(test_addFailsOnDifferentInputDimensions);
|
||||
RUN_TEST(test_addSupportsBroadcasting);
|
||||
RUN_TEST(test_multiplyReturnsCorrectResults);
|
||||
RUN_TEST(test_multiplyFailsOnWrongInputDimensions);
|
||||
RUN_TEST(test_getMatrixAtReturnsCorrectResult);
|
||||
RUN_TEST(test_getMatrixAtFailsOnIndicesOutOfRange);
|
||||
RUN_TEST(test_setMatrixAtSetsCorrectValue);
|
||||
RUN_TEST(test_setMatrixAtFailsOnIndicesOutOfRange);
|
||||
|
||||
return UNITY_END();
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user