C++ (Cpp) TEST_ASSERT_FLOAT_WITHIN Exemples

Exemple #1

Fichier : testunity.c Projet : chaicko/tdd_book_code

void testFloatsWithinDelta(void)
{
    TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
    TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
    TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
    TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
}

Exemple #2

Fichier : test_TemperatureFilter.c Projet : ThrowTheSwitch/ceedling-gem

void testShouldInitializeTemperatureAfterCallToInit(void)
{
  TemperatureFilter_Init();
  TemperatureFilter_ProcessInput(17.8f);
  TEST_ASSERT_FLOAT_WITHIN(0.0001f, 17.8f, TemperatureFilter_GetTemperatureInCelcius());

  TemperatureFilter_Init();
  TemperatureFilter_ProcessInput(32.6f);
  TEST_ASSERT_FLOAT_WITHIN(0.0001f, 32.6f, TemperatureFilter_GetTemperatureInCelcius());
}

Exemple #3

Fichier : test_IT.c Projet : KyOChiang/ImageCompressor

void test_two_D_DCT_transform_array_of_3_elements_and_should_invert_back_to_original_by_IDCT(){
  float imageMatrix[3][3] = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}};
  int size = 3;
  
  twoD_DCT(size, imageMatrix);
  
  TEST_ASSERT_FLOAT_WITHIN(0.001, 5.999, imageMatrix[0][0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -2.449, imageMatrix[0][1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[0][2]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[1][0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[1][1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[1][2]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2][0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2][1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2][2]);
  
  twoD_IDCT(size, imageMatrix);
  
  TEST_ASSERT_EQUAL(1,imageMatrix[0][0]);
  TEST_ASSERT_EQUAL(1,imageMatrix[1][0]);
  TEST_ASSERT_EQUAL(1,imageMatrix[2][0]);
  TEST_ASSERT_EQUAL(2,imageMatrix[0][1]);
  TEST_ASSERT_EQUAL(2,imageMatrix[1][1]);
  TEST_ASSERT_EQUAL(2,imageMatrix[2][1]);
  TEST_ASSERT_EQUAL(3,imageMatrix[0][2]);
  TEST_ASSERT_EQUAL(3,imageMatrix[1][2]);
  TEST_ASSERT_EQUAL(3,imageMatrix[2][2]);
}

Exemple #4

Fichier : test_DCT.c Projet : KyOChiang/ImageCompressor

void test_oneD_DCT_with_3_elements_on_row(){
  float imageMatrix[3] = {1, 2, 3};
  
  int numOfElem = sizeof(imageMatrix)/sizeof(float);
  
  oneD_DCT_row(imageMatrix, numOfElem);
  
  TEST_ASSERT_FLOAT_WITHIN(0.001, 3.464, imageMatrix[0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -1.414, imageMatrix[1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2]);
}

Exemple #5

Fichier : test_DCT.c Projet : KyOChiang/ImageCompressor

void test_oneD_DCT_with_3_elements_on_column(){
  int col = 0, size = 3;
  float imageMatrix[3][3] = {{1,0,0}, {2,0,0}, {3,0,0}};
  
  int numOfElem = sizeof(imageMatrix)/sizeof(float);
  
  oneD_DCT_column(size, imageMatrix, col);
  
  TEST_ASSERT_FLOAT_WITHIN(0.001, 3.464, imageMatrix[0][0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -1.414, imageMatrix[1][0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2][0]);
}

Exemple #6

Fichier : test_IT.c Projet : KyOChiang/ImageCompressor

void test_DCT_transform_array_of_8_elements_and_should_invert_back_to_original_by_IDCT(){
  float imageMatrix[8] = {1,2,3,4,5,6,7,8};

  oneD_DCT_row(imageMatrix, sizeof(imageMatrix)/sizeof(float));
  
  TEST_ASSERT_FLOAT_WITHIN(0.001, 12.727, imageMatrix[0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -6.442, imageMatrix[1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -0.673, imageMatrix[3]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[4]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -0.200, imageMatrix[5]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[6]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -0.050, imageMatrix[7]);
  
  oneD_IDCT_row(imageMatrix, 8);
  round_float(imageMatrix, 8);
  
  TEST_ASSERT_EQUAL(1,imageMatrix[0]);
  TEST_ASSERT_EQUAL(2,imageMatrix[1]);
  TEST_ASSERT_EQUAL(3,imageMatrix[2]);
  TEST_ASSERT_EQUAL(4,imageMatrix[3]);
  TEST_ASSERT_EQUAL(5,imageMatrix[4]);
  TEST_ASSERT_EQUAL(6,imageMatrix[5]);
  TEST_ASSERT_EQUAL(7,imageMatrix[6]);
  TEST_ASSERT_EQUAL(8,imageMatrix[7]);
}

Exemple #7

Fichier : TestTemperatureCalculator.c Projet : ThrowTheSwitch/Ceedling

void testTemperatureCalculatorShouldCalculateTemperatureFromMillivolts(void)
{
  float result;

  // Series resistor is 5k Ohms; Reference voltage is 3.0V
  // R(t) = A * e^(B*t); R is resistance of thermisor; t is temperature in C
  result = TemperatureCalculator_Calculate(1000);
  TEST_ASSERT_FLOAT_WITHIN(0.01f, 25.0f, result);

  result = TemperatureCalculator_Calculate(2985);
  TEST_ASSERT_FLOAT_WITHIN(0.01f, 68.317f, result);

  result = TemperatureCalculator_Calculate(3);
  TEST_ASSERT_FLOAT_WITHIN(0.01f, -19.96f, result);
}

Exemple #8

Fichier : test_IT.c Projet : KyOChiang/ImageCompressor

void test_DCT_transform_array_of_3_elements_and_should_invert_back_to_original_by_IDCT(){
  float imageMatrix[3] = {1, 2, 3};
  
  oneD_DCT_row(imageMatrix, sizeof(imageMatrix)/sizeof(float));
  
  TEST_ASSERT_FLOAT_WITHIN(0.001, 3.464, imageMatrix[0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -1.414, imageMatrix[1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2]);
  
  oneD_IDCT_row(imageMatrix, 3);
  round_float(imageMatrix, 3);
  
  TEST_ASSERT_EQUAL(1,imageMatrix[0]);
  TEST_ASSERT_EQUAL(2,imageMatrix[1]);
  TEST_ASSERT_EQUAL(3,imageMatrix[2]);
}

Exemple #9

Fichier : test_DCT.c Projet : KyOChiang/ImageCompressor

void test_cos_DCT_case1(){
	float result;
	
	result = cos_DCT(0, 1, 3);
	
	TEST_ASSERT_FLOAT_WITHIN(0.001, 0.866, result);
}

Exemple #10

Fichier : test_DCT.c Projet : KyOChiang/ImageCompressor

void test_cos_DCT_case3(){
	float result;
	
	result = cos_DCT(2, 2, 3);
	
	TEST_ASSERT_FLOAT_WITHIN(0.001, 0.5, result);
}

Exemple #11

Fichier : test_DCT.c Projet : KyOChiang/ImageCompressor

void test_cos_DCT_case4(){
	float result;
	
	result = cos_DCT(5, 1, 4);
	
	TEST_ASSERT_FLOAT_WITHIN(0.001, -0.382, result);
}

Exemple #12

Fichier : test_TemperatureFilter.c Projet : ThrowTheSwitch/ceedling-gem

void setValueAndVerifyResponse(float input, float response)
{
  float actual;
  TemperatureFilter_ProcessInput(input);
  actual = TemperatureFilter_GetTemperatureInCelcius();
  TEST_ASSERT_FLOAT_WITHIN(0.0001f, response, actual);
}

Exemple #13

Fichier : test_rand.c Projet : bryongloden/randomness_test

TEST(RandTest, test_block_freq_not1)
{
  unsigned char testbuf[16] = {0xff, 0xaf, 0xff, 0xff,
                              0xff, 0xff, 0xff, 0xff,
                              0xff, 0xff, 0xff, 0xff,
                              0xff, 0xff, 0xff, 0xff};
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0.0, freq_block(testbuf, 16, 4));
}

Exemple #14

Fichier : test_rand.c Projet : bryongloden/randomness_test

TEST(RandTest, test_runs_rand1)
{
  unsigned char testbuf[16] = {0xc1, 0xaf, 0x5d, 0xdd,
                               0xd9, 0x61, 0x03, 0xc9,
                               0x54, 0x87, 0xd7, 0x61,
                               0x13, 0xf2, 0x63, 0x20};
  TEST_ASSERT_FLOAT_WITHIN(0.1, 0.48, runs(testbuf, 16));
}

Exemple #15

Fichier : test_rand.c Projet : bryongloden/randomness_test

TEST(RandTest, test_runs_one_block_rand1)
{
  unsigned char testbuf[16] = {0xc1, 0xaf, 0x5d, 0xdd,
                               0xd9, 0x61, 0x03, 0xc9,
                               0x54, 0x87, 0xd7, 0x61,
                               0x13, 0xf2, 0x63, 0x20};
  TEST_ASSERT_FLOAT_WITHIN(0.01, 0.63, runs_one_block(testbuf, 16, 1));
}

Exemple #16

Fichier : test_rand.c Projet : bryongloden/randomness_test

TEST(RandTest, test_runs_one_block_rand2)
{
  unsigned char testbuf[16] = {0x1e, 0xbf, 0xeb, 0x16,
                               0xd8, 0x25, 0xdb, 0xc4,
                               0x02, 0x6a, 0x2f, 0x49,
                               0x14, 0x91, 0x1c, 0x51};
  TEST_ASSERT_FLOAT_WITHIN(0.01, 0.42, runs_one_block(testbuf, 16,1));
}

Exemple #17

Fichier : test_rand.c Projet : bryongloden/randomness_test

TEST(RandTest, test_runs_one_block_not1)
{
  unsigned char testbuf[16] = {0xaa, 0xaa, 0xbb, 0xff,
                               0x9f, 0xff, 0xff, 0x00,
                               0xff, 0xff, 0xff, 0x00,
                               0xaa, 0xaa, 0x00, 0x00};
  TEST_ASSERT_FLOAT_WITHIN(0.1, 0.0001, runs_one_block(testbuf, 16,1));
}

Exemple #18

Fichier : xtest_Person.c Projet : jwchong93/Map

void test_personNew_given_Ali_23_64_should_create_the_person()
{
	Person *person = personNew("Ali",23,64.0);
	TEST_ASSERT_NOT_NULL(person);
	TEST_ASSERT_EQUAL_STRING("Ali",person->name);
	TEST_ASSERT_EQUAL(23,person->age);
	TEST_ASSERT_FLOAT_WITHIN(0.0001,64.0,person->weight);
}

Exemple #19

Fichier : test_DCT.c Projet : KyOChiang/ImageCompressor

void test_adderFunction_case2(){
  float result;
  float imageMatrix[3] = {1, 2, 3};
  
  result = adderFunction(imageMatrix, 2, 3);
  
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, result);
}

Exemple #20

Fichier : test_rand.c Projet : bryongloden/randomness_test

TEST(RandTest, test_block_freq_rand2)
{
  unsigned char testbuf[16] = {0xc1, 0xaf, 0x5d, 0xdd,
                               0xd9, 0x61, 0x03, 0xc9,
                               0x54, 0x87, 0xd7, 0x61,
                               0x13, 0xf2, 0x63, 0x20};
  TEST_ASSERT_FLOAT_WITHIN(0.01, 0.45, freq_block(testbuf, 16, 4));
}

Exemple #21

Fichier : test_all.c Projet : RFMicron/Hermes

void test_uart_baud_rate()
{
    u32 sysclk = 16000000ULL;
    u32 baudrate = 115200;
    u32 actbaudrate = 0;
    uartInitialize(sysclk,baudrate,&actbaudrate);

    if(actbaudrate != baudrate)
        printf("%ld baud instead of %ld baud\n",actbaudrate,baudrate);
    TEST_ASSERT_FLOAT_WITHIN(0.2,1.0,baudrate/actbaudrate);
}

Exemple #22

Fichier : test_DCT.c Projet : KyOChiang/ImageCompressor

void test_2D_DCTFunction_given_3by3_matrix_1_2_3(){
  float imageMatrix[3][3] = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}};
  int size = 3;
  
  twoD_DCT(size, imageMatrix);
  
  TEST_ASSERT_FLOAT_WITHIN(0.001, 5.999, imageMatrix[0][0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -2.449, imageMatrix[0][1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[0][2]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[1][0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[1][1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[1][2]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2][0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2][1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2][2]);
  
}

Exemple #23

Fichier : test_all.c Projet : RFMicron/Hermes

void test_i2c_speed()
{
    i2cConfig.i2cAddressMode = I2C_ADDRESS_MODE_7_BIT;
    i2cConfig.i2cClockMode = I2C_SCK_100KHZ;
    i2cConfig.i2cModule = I2C1_MODULE;

    i2cInitialize(4000000ULL, &i2cConfig, &i2cConfigReal);
    u32 actualSpeed = 4000000ULL/(I2C1BRG + 1 + (4000000ULL/10000000));
    if(actualSpeed != 100000)
        printf("%ld instead of %ld\n",actualSpeed,100000);
    TEST_ASSERT_FLOAT_WITHIN(0.2,1.0,100000/actualSpeed);
}

Exemple #24

Fichier : test_unity.c Projet : mjago/old_Unity

void testFloatsNotWithinDelta(void)
{
    int failed;

    EXPECT_ABORT_BEGIN
    TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
    EXPECT_ABORT_END

    failed = Unity.CurrentTestFailed;
    Unity.CurrentTestFailed = 0;

    VERIFY_FAILURE_WAS_CAUGHT
}

Exemple #25

Fichier : test_DCT.c Projet : KyOChiang/ImageCompressor

void test_oneD_DCT_with_8_elements(){
  float imageMatrix[8] = {8, 7, 6, 5, 4, 3, 2, 1};
  
  int numOfElem = sizeof(imageMatrix)/sizeof(float);
  
  oneD_DCT_row(imageMatrix, numOfElem);
  
  TEST_ASSERT_FLOAT_WITHIN(0.001, 12.727, imageMatrix[0]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 6.442, imageMatrix[1]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[2]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0.673, imageMatrix[3]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, -0, imageMatrix[4]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0.200, imageMatrix[5]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0, imageMatrix[6]);
  TEST_ASSERT_FLOAT_WITHIN(0.001, 0.050, imageMatrix[7]);
}

Exemple #26

Fichier : test_all.c Projet : RFMicron/Hermes

void test_spi_speed()
{
    spiConfig_t spiConfigIn;

    spiConfigIn.frequency =  100000;
    spiConfigIn.instance = SPI1;
    spiConfigIn.clockPhase = 1;
    spiConfigIn.clockPolarity = 0;
    spiInitialize(&spiConfigIn,NULL);

    u32 actFrequency = 4000000ULL / (2*(SPI1BRGL+1));

    if(actFrequency != spiConfigIn.frequency)
        printf("%ld instead of %ld\n",actFrequency,spiConfigIn.frequency);
    TEST_ASSERT_FLOAT_WITHIN(0.2,1.0,spiConfigIn.frequency/actFrequency);
}

Exemple #27

Fichier : TestTemperatureCalculator.c Projet : 2kranki/CMock

void testShouldReturnNegativeInfinityWhen_0_millivoltsInput(void)
{
  TEST_ASSERT_FLOAT_WITHIN(0.0000001f, -INFINITY, TemperatureCalculator_Calculate(0));
}

Exemple #28

Fichier : cenMathTest.c Projet : Aveline67/cen-electronic

void test_mod2PI(void) {
    float actual = mod2PI(0.0f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, 0.0f, actual);

    actual = mod2PI(PI);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, PI, actual);

    actual = mod2PI(PI - 0.0001f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, PI - 0.0001F, actual);

    actual = mod2PI(PI + 0.0001f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, -PI + 0.0001F, actual);

    actual = mod2PI(PI + 2.0f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, -PI + 2.0f, actual);

    actual = mod2PI(5 * PI + 1.0f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, -PI + 1.0f, actual);

    actual = mod2PI(5 * PI - 1.0f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, PI - 1.0f, actual);

    actual = mod2PI(-PI - 2.0f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, +PI - 2.0f, actual);

    actual = mod2PI(-5 * PI + 1.0f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, -PI + 1.0f, actual);

    actual = mod2PI(-PI - 0.0001f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, PI - 0.0001F, actual);

    actual = mod2PI(-PI + 0.0001f);
    TEST_ASSERT_FLOAT_WITHIN(UNITY_FLOAT_PRECISION, -PI + 0.0001F, actual);
}

Exemple #29

Fichier : test.c Projet : Groonly/Refaktorering

void test_ohmsLag_diffrent_typ_of_values(void)
{
TEST_ASSERT_FLOAT_WITHIN(DECIMAL_PRECISSION, 15, ohmsLag(5, 3));
TEST_ASSERT_FLOAT_WITHIN(DECIMAL_PRECISSION, 0, ohmsLag(0, 0));
}

Exemple #30

Fichier : test_rand.c Projet : bryongloden/randomness_test

TEST(RandTest, test_mono_freq_rand2)
{
  unsigned char testbuf[2] = {0xf0, 0xa7};
  TEST_ASSERT_FLOAT_WITHIN(0.01, 0.61, freq_monobit(testbuf, 2));
}