mirror of
git://nv-tegra.nvidia.com/linux-nvgpu.git
synced 2025-12-22 17:36:20 +03:00
gpu: nvgpu: arithmetic bvec tests
Add BVEC tests for following functions: nvgpu_safe_sub_u8, nvgpu_safe_add_u32, nvgpu_safe_add_s32, nvgpu_safe_sub_u32, nvgpu_safe_sub_s32, nvgpu_safe_mult_u32, nvgpu_safe_add_u64, nvgpu_safe_add_s64, nvgpu_safe_sub_u64, nvgpu_safe_sub_s64, nvgpu_safe_mult_u64, nvgpu_safe_mult_s64 JIRA NVGPU-6412 Change-Id: Ie4f1138318314c3f53b1f188e1ca45f681ca895e Signed-off-by: Sagar Kamble <skamble@nvidia.com> Reviewed-on: https://git-master.nvidia.com/r/c/linux-nvgpu/+/2553170 (cherry picked from commit 74c32f975c181107372957a28aad0cb5278f42b2) Reviewed-on: https://git-master.nvidia.com/r/c/linux-nvgpu/+/2623630 Reviewed-by: Vaibhav Kachore <vkachore@nvidia.com> Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com> Tested-by: mobile promotions <svcmobile_promotions@nvidia.com> GVS: Gerrit_Virtual_Submit
This commit is contained in:
Sagar Kamble
committed by
mobile promotions
mobile promotions
parent
3e7643bb9c
commit
d944313a54
@@ -1,5 +1,5 @@
|
|||||||
/*
|
/*
|
||||||
* Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
|
* Copyright (c) 2020-2021, NVIDIA CORPORATION. All rights reserved.
|
||||||
*
|
*
|
||||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||||
* copy of this software and associated documentation files (the "Software"),
|
* copy of this software and associated documentation files (the "Software"),
|
||||||
@@ -29,132 +29,335 @@
|
|||||||
|
|
||||||
#include "static_analysis.h"
|
#include "static_analysis.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* unsigned addition tests
|
||||||
|
*
|
||||||
|
* parameters:
|
||||||
|
* type_name: type (u8, u32 etc.)
|
||||||
|
* type_max : Maximum value of the type.
|
||||||
|
* tmp_operand: random value in the set (1, Maximum value)
|
||||||
|
*
|
||||||
|
* Boundary values: (0, 1, max-1, max)
|
||||||
|
*
|
||||||
|
* Valid tests: Addition result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* Invalid tests: Addition result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*/
|
||||||
|
#define GENERATE_ARITHMETIC_ADD_TESTS(type_name, type_max, tmp_operand) do {\
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(type_max, 0) == type_max, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(type_max - 1, 1) == type_max, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(type_max - tmp_operand, tmp_operand) == type_max, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(1, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(tmp_operand, type_max - tmp_operand + 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_max - 1, tmp_operand > 1 ? tmp_operand : 2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* signed addition tests
|
||||||
|
*
|
||||||
|
* parameters:
|
||||||
|
* type_name: type (s32, s64 etc.)
|
||||||
|
* type_min: Minimum value of the type.
|
||||||
|
* type_max : Maximum value of the type.
|
||||||
|
* tmp_operand1: random positive value in the set (1, Maximum value / 2)
|
||||||
|
* tmp_operand2: random negative value in the set (-1, Minimum value / 2)
|
||||||
|
*
|
||||||
|
* Boundary values: (min, min+1, -1, 0, 1, max-1, max)
|
||||||
|
*
|
||||||
|
* Valid tests: Addition result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* Invalid tests: Addition result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*/
|
||||||
|
#define GENERATE_ARITHMETIC_SIGNED_ADD_TESTS(type_name, type_min, type_max, tmp_operand1, tmp_operand2) do {\
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(type_min, type_max) == -1, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(0, type_max) == type_max, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(-1, -1) == -2, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(-1, 1) == 0, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(1, 1) == 2, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(type_max - tmp_operand1, tmp_operand1) == type_max, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(type_min - tmp_operand2, tmp_operand2) == type_min, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(tmp_operand1, tmp_operand2) == tmp_operand1 + tmp_operand2, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(tmp_operand1, type_min + 1) == tmp_operand1 + type_min + 1, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_add_##type_name(type_max - 1, tmp_operand2) == type_max - 1 + tmp_operand2, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_max - tmp_operand1 + 1, tmp_operand1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_max, tmp_operand1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_max, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_min - tmp_operand2 - 1, tmp_operand2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_min, tmp_operand2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_min, type_min)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_min + 1, type_min + 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_max - 1, type_max - 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_max - 1, tmp_operand1 > 1 ? tmp_operand1 : 2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_add_##type_name(type_min + 1, tmp_operand2 < -1 ? tmp_operand2 : -2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* unsigned subtraction tests
|
||||||
|
*
|
||||||
|
* parameters:
|
||||||
|
* type_name: type (u8, u32 etc.)
|
||||||
|
* type_max : Maximum value of the type.
|
||||||
|
* tmp_operand: random value in the set (1, Maximum value)
|
||||||
|
*
|
||||||
|
* Boundary values: (0, 1, max-1, max)
|
||||||
|
*
|
||||||
|
* Valid tests: Subtraction result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* Invalid tests: Subtraction result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*/
|
||||||
|
#define GENERATE_ARITHMETIC_SUBTRACT_TESTS(type_name, type_max, tmp_operand) do {\
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(0, 0) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(1, 0) == 1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_max, tmp_operand) == type_max - tmp_operand, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(tmp_operand, 0) == tmp_operand, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_max, type_max - 1) == 1, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_max - 1, 1) == type_max - 2, \
|
||||||
|
return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(0, 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(0, tmp_operand)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(0, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(tmp_operand, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_max - 1, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* signed subtraction tests
|
||||||
|
*
|
||||||
|
* parameters:
|
||||||
|
* type_name: type (s32, s64 etc.)
|
||||||
|
* type_min: Minimum value of the type.
|
||||||
|
* type_max : Maximum value of the type.
|
||||||
|
* tmp_operand1: random positive value in the set (1, Maximum value / 2)
|
||||||
|
* tmp_operand2: random negative value in the set (-1, Minimum value / 2)
|
||||||
|
*
|
||||||
|
* Boundary values: (min, min+1, -1, 0, 1, max-1, max)
|
||||||
|
*
|
||||||
|
* Valid tests: Subtraction result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* Invalid tests: Subtraction result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*/
|
||||||
|
#define GENERATE_ARITHMETIC_SIGNED_SUBTRACT_TESTS(type_name, type_min, type_max, tmp_operand1, tmp_operand2) do {\
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(tmp_operand2, tmp_operand2) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(tmp_operand2, tmp_operand1) == tmp_operand2 - tmp_operand1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(tmp_operand1, tmp_operand2) == tmp_operand1 - tmp_operand2, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(0, 0) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(0, type_max) == 0 - type_max, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_max, 0) == type_max, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(-1, -1) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(-1, 1) == -2, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(1, -1) == 2, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(1, 1) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_min + 1, type_min + 1) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_min, type_min) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_max - 1, type_max - 1) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_max, type_max) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_min + 1, tmp_operand2) == type_min + 1 - tmp_operand2, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_max - 1, tmp_operand1) == type_max - 1 - tmp_operand1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(tmp_operand2, tmp_operand2 - type_min) == type_min, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_sub_##type_name(type_max, type_max - tmp_operand1) == tmp_operand1, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_min, tmp_operand1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_max, tmp_operand2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_max - 1, type_min + 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_min + 1, type_max - 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_max - 1, tmp_operand2 < -1 ? tmp_operand2 : -2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_min + 1, tmp_operand1 > 1 ? tmp_operand1 : 2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(0, type_min)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_min, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_sub_##type_name(type_max, type_min)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* unsigned multiplication tests
|
||||||
|
*
|
||||||
|
* parameters:
|
||||||
|
* type_name: type (u8, u32 etc.)
|
||||||
|
* type_max : Maximum value of the type.
|
||||||
|
* tmp_operand: random value in the set (1, Maximum value / 2)
|
||||||
|
*
|
||||||
|
* Boundary values: (0, 1, max-1, max)
|
||||||
|
*
|
||||||
|
* Valid tests: Multiplication result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* Invalid tests: Multiplication result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*/
|
||||||
|
#define GENERATE_ARITHMETIC_MULT_TESTS(type_name, type_max, tmp_operand) do {\
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(0, type_max) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(type_max - 1, 1) == type_max - 1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(tmp_operand, 2) == tmp_operand * 2, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_max - 1, 2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_max - 1, tmp_operand > 1 ? tmp_operand : 2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_max, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* signed multiplication tests
|
||||||
|
*
|
||||||
|
* parameters:
|
||||||
|
* type_name: type (s32, s64 etc.)
|
||||||
|
* type_min: Minimum value of the type.
|
||||||
|
* type_max : Maximum value of the type.
|
||||||
|
* tmp_operand1: random positive value in the set (1, Maximum value / 2)
|
||||||
|
* tmp_operand2: random negative value in the set (-1, Minimum value / 2)
|
||||||
|
*
|
||||||
|
* Boundary values: (min, min+1, -1, 0, 1, max-1, max)
|
||||||
|
*
|
||||||
|
* Valid tests: Multiplication result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* Invalid tests: Multiplication result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*/
|
||||||
|
#define GENERATE_ARITHMETIC_SIGNED_MULT_TESTS(type_name, type_min, type_max, tmp_operand1, tmp_operand2) do {\
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(0, type_max) == 0, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(1, type_min) == type_min, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(-1, -1) == 1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(-1, 1) == -1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(1, 1) == 1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(tmp_operand1, 2) == tmp_operand1 * 2, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(tmp_operand2, 2) == tmp_operand2 * 2, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(type_max, -1) == type_max * -1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(type_max - 1, -1) == (type_max - 1) * -1, return UNIT_FAIL); \
|
||||||
|
unit_assert(nvgpu_safe_mult_##type_name(type_min + 1, -1) == (type_min + 1) * -1, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_max, 2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_max, -2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_min, 2)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_min, -1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_min, type_min)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_max, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_min, type_max)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_min + 1, type_min + 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_max - 1, type_max - 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
err = EXPECT_BUG((void)nvgpu_safe_mult_##type_name(type_min + 1, type_max - 1)); \
|
||||||
|
unit_assert(err != 0, return UNIT_FAIL); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
int test_arithmetic(struct unit_module *m, struct gk20a *g, void *args)
|
int test_arithmetic(struct unit_module *m, struct gk20a *g, void *args)
|
||||||
{
|
{
|
||||||
|
s64 tmp_s64, tmp_s64_neg;
|
||||||
|
s32 tmp_s32, tmp_s32_neg;
|
||||||
|
u64 tmp_u64;
|
||||||
|
u32 tmp_u32;
|
||||||
|
u8 tmp_u8;
|
||||||
int err;
|
int err;
|
||||||
|
|
||||||
|
srand(time(0));
|
||||||
|
|
||||||
|
/* random value in the set (1, U8_MAX - 1) */
|
||||||
|
tmp_u8 = rand() % U8_MAX ?: 1;
|
||||||
|
|
||||||
|
/* random value in the set ((u32)1, (u32)(U32_MAX - 1)) */
|
||||||
|
tmp_u32 = (u32)((rand() % U32_MAX) ?: 1);
|
||||||
|
|
||||||
|
/* random value in the set ((s32)1, (s32)(U32_MAX - 1) / 2) */
|
||||||
|
tmp_s32 = (s32)((rand() % U32_MAX) / 2 ?: 1);
|
||||||
|
|
||||||
|
/* random value in the set ((s32)-1, (s32)-((U32_MAX - 1) / 2)) */
|
||||||
|
tmp_s32_neg = (s32)(0 - (rand() % U32_MAX) / 2) ?: -1;
|
||||||
|
|
||||||
|
/* random value in the set ((u64)1, (u64)(U64_MAX - 1)) */
|
||||||
|
tmp_u64 = (u64)((rand() % U64_MAX) ?: 1);
|
||||||
|
|
||||||
|
/* random value in the set ((s64)1, (s64)(U64_MAX - 1) / 2) */
|
||||||
|
tmp_s64 = (s64)((rand() % U64_MAX) / 2 ?: 1);
|
||||||
|
|
||||||
|
/* random value in the set ((s64)-1, (s64)-((U64_MAX - 1) / 2)) */
|
||||||
|
tmp_s64_neg = (s64)(0 - (rand() % U64_MAX) / 2) ?: -1;
|
||||||
|
|
||||||
|
unit_info(m, "random operands\nu8: %u, u32: %u, s32: %d, s32_neg: %d\nu64: %llu, s64: %lld, s64_neg: %lld\n",
|
||||||
|
tmp_u8, tmp_u32, tmp_s32, tmp_s32_neg, tmp_u64, tmp_s64, tmp_s64_neg);
|
||||||
|
|
||||||
/* U8 sub */
|
/* U8 sub */
|
||||||
unit_assert(nvgpu_safe_sub_u8(1, 1) == 0, return UNIT_FAIL);
|
GENERATE_ARITHMETIC_SUBTRACT_TESTS(u8, U8_MAX, tmp_u8);
|
||||||
unit_assert(nvgpu_safe_sub_u8(U8_MAX, U8_MAX) == 0,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_sub_u8(0, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* U32 add */
|
/* U32 add */
|
||||||
unit_assert(nvgpu_safe_add_u32(U32_MAX-1, 1) == U32_MAX,
|
GENERATE_ARITHMETIC_ADD_TESTS(u32, U32_MAX, tmp_u32);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_add_u32(U32_MAX, 0) == U32_MAX,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_add_u32(U32_MAX, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* S32 add */
|
/* S32 add */
|
||||||
unit_assert(nvgpu_safe_add_s32(INT_MAX-1, 1) == INT_MAX,
|
GENERATE_ARITHMETIC_SIGNED_ADD_TESTS(s32, INT_MIN, INT_MAX, tmp_s32, tmp_s32_neg);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_add_s32(INT_MAX, 0) == INT_MAX,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_add_s32(INT_MIN+1, -1) == INT_MIN,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_add_s32(INT_MAX, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_add_s32(INT_MIN, -1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* U32 sub */
|
/* U32 sub */
|
||||||
unit_assert(nvgpu_safe_sub_u32(1, 1) == 0, return UNIT_FAIL);
|
GENERATE_ARITHMETIC_SUBTRACT_TESTS(u32, U32_MAX, tmp_u32);
|
||||||
unit_assert(nvgpu_safe_sub_u32(U32_MAX, U32_MAX) == 0,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_sub_u32(0, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* S32 sub */
|
/* S32 sub */
|
||||||
unit_assert(nvgpu_safe_sub_s32(INT_MIN+1, 1) == INT_MIN,
|
GENERATE_ARITHMETIC_SIGNED_SUBTRACT_TESTS(s32, INT_MIN, INT_MAX, tmp_s32, tmp_s32_neg);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_sub_s32(INT_MAX-1, -1) == INT_MAX,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_sub_s32(INT_MIN, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_sub_s32(INT_MAX, -1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* U32 Mult */
|
/* U32 Mult */
|
||||||
unit_assert(nvgpu_safe_mult_u32(0, 0) == 0,
|
GENERATE_ARITHMETIC_MULT_TESTS(u32, U32_MAX, tmp_u32);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_u32(U32_MAX, 0) == 0,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_u32(U32_MAX, 1) == U32_MAX,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_mult_u32(U32_MAX, 2));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* U64 add */
|
/* U64 add */
|
||||||
unit_assert(nvgpu_safe_add_u64(U64_MAX-1, 1) == U64_MAX,
|
GENERATE_ARITHMETIC_ADD_TESTS(u64, U64_MAX, tmp_u64);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_add_u64(U64_MAX, 0) == U64_MAX,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_add_u64(U64_MAX, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* S64 add */
|
/* S64 add */
|
||||||
unit_assert(nvgpu_safe_add_s64(LONG_MAX-1, 1) == LONG_MAX,
|
GENERATE_ARITHMETIC_SIGNED_ADD_TESTS(s64, LONG_MIN, LONG_MAX, tmp_s64, tmp_s64_neg);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_add_s64(LONG_MAX, 0) == LONG_MAX,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_add_s64(LONG_MIN+1, -1) == LONG_MIN,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_add_s64(LONG_MAX, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_add_s64(LONG_MIN, -1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* U64 sub */
|
/* U64 sub */
|
||||||
unit_assert(nvgpu_safe_sub_u64(1, 1) == 0, return UNIT_FAIL);
|
GENERATE_ARITHMETIC_SUBTRACT_TESTS(u64, U64_MAX, tmp_u64);
|
||||||
unit_assert(nvgpu_safe_sub_u64(U64_MAX, U64_MAX) == 0,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_sub_u64(0, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* S64 sub */
|
/* S64 sub */
|
||||||
unit_assert(nvgpu_safe_sub_s64(LONG_MIN+1, 1) == LONG_MIN,
|
GENERATE_ARITHMETIC_SIGNED_SUBTRACT_TESTS(s64, LONG_MIN, LONG_MAX, tmp_s64, tmp_s64_neg);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_sub_s64(LONG_MAX-1, -1) == LONG_MAX,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_sub_s64(LONG_MIN, 1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_sub_s64(LONG_MAX, -1));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* U64 Mult */
|
/* U64 Mult */
|
||||||
unit_assert(nvgpu_safe_mult_u64(0, 0) == 0,
|
GENERATE_ARITHMETIC_MULT_TESTS(u64, U64_MAX, tmp_u64);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_u64(U64_MAX, 0) == 0,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_u64(U64_MAX, 1) == U64_MAX,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_mult_u64(U64_MAX, 2));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
/* S64 Mult */
|
/* S64 Mult */
|
||||||
unit_assert(nvgpu_safe_mult_s64(LONG_MAX, 1) == LONG_MAX,
|
GENERATE_ARITHMETIC_SIGNED_MULT_TESTS(s64, LONG_MIN, LONG_MAX, tmp_s64, tmp_s64_neg);
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_s64(LONG_MAX, -1) == (-1 * LONG_MAX),
|
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_s64(-1, LONG_MAX) == (-1 * LONG_MAX),
|
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_s64(0, LONG_MAX) == 0,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_s64(-1, -1) == 1,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
unit_assert(nvgpu_safe_mult_s64(0, -1) == 0,
|
|
||||||
return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_mult_s64(LONG_MAX, 2));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_mult_s64(LONG_MAX, -2));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_mult_s64(-1*LONG_MAX, 2));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
err = EXPECT_BUG((void)nvgpu_safe_mult_s64(-1*LONG_MAX, -2));
|
|
||||||
unit_assert(err != 0, return UNIT_FAIL);
|
|
||||||
|
|
||||||
return UNIT_SUCCESS;
|
return UNIT_SUCCESS;
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,5 @@
|
|||||||
/*
|
/*
|
||||||
* Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
|
* Copyright (c) 2020-2021, NVIDIA CORPORATION. All rights reserved.
|
||||||
*
|
*
|
||||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||||
* copy of this software and associated documentation files (the "Software"),
|
* copy of this software and associated documentation files (the "Software"),
|
||||||
@@ -37,7 +37,7 @@ struct unit_module;
|
|||||||
*
|
*
|
||||||
* Description: Verify functionality of static analysis safe arithmetic APIs.
|
* Description: Verify functionality of static analysis safe arithmetic APIs.
|
||||||
*
|
*
|
||||||
* Test Type: Feature, Error guessing
|
* Test Type: Feature, Error guessing, Boundary Value
|
||||||
*
|
*
|
||||||
* Targets: nvgpu_safe_sub_u8, nvgpu_safe_add_u32, nvgpu_safe_add_s32,
|
* Targets: nvgpu_safe_sub_u8, nvgpu_safe_add_u32, nvgpu_safe_add_s32,
|
||||||
* nvgpu_safe_sub_u32, nvgpu_safe_sub_s32, nvgpu_safe_mult_u32,
|
* nvgpu_safe_sub_u32, nvgpu_safe_sub_s32, nvgpu_safe_mult_u32,
|
||||||
@@ -46,6 +46,66 @@ struct unit_module;
|
|||||||
*
|
*
|
||||||
* Input: None
|
* Input: None
|
||||||
*
|
*
|
||||||
|
* -# Unsigned addition tests:
|
||||||
|
* Boundary values: {0, max}
|
||||||
|
*
|
||||||
|
* Equivalence classes:
|
||||||
|
* Variable: Addition result of two unsigned operands.
|
||||||
|
* - Valid tests: Addition result within range for each boundary value and
|
||||||
|
* random value in the set.
|
||||||
|
* - Invalid tests: Addition result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*
|
||||||
|
* -# Signed addition tests:
|
||||||
|
* Boundary values: {min, 0, max}
|
||||||
|
*
|
||||||
|
* Equivalence classes:
|
||||||
|
* Variable: Addition result of two signed operands.
|
||||||
|
* - Valid tests: Addition result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* - Invalid tests: Addition result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*
|
||||||
|
* -# Unsigned subtraction tests:
|
||||||
|
* Boundary values: {0, max}
|
||||||
|
*
|
||||||
|
* Equivalence classes:
|
||||||
|
* Variable: Subtraction result of two unsigned operands.
|
||||||
|
* - Valid tests: Subtraction result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* - Invalid tests: Subtraction result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*
|
||||||
|
* -# Signed subtraction tests:
|
||||||
|
* Boundary values: {min, 0, max}
|
||||||
|
*
|
||||||
|
* Equivalence classes:
|
||||||
|
* Variable: Subtraction result of two signed operands.
|
||||||
|
* - Valid tests: Subtraction output within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* - Invalid tests: Subtraction output out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*
|
||||||
|
* -# Unsigned multiplication tests:
|
||||||
|
* Boundary values: {0, max}
|
||||||
|
*
|
||||||
|
* Equivalence classes:
|
||||||
|
* Variable: Multiplication result of two unsigned operands.
|
||||||
|
* - Valid tests: Multiplication result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* - Invalid tests: Multiplication result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*
|
||||||
|
* -# Signed multiplication tests:
|
||||||
|
* Boundary values: {min, 0, max}
|
||||||
|
*
|
||||||
|
* Equivalence classes:
|
||||||
|
* Variable: Multiplication result of two signed operands.
|
||||||
|
* - Valid tests: Multiplication result within range for each boundary value and
|
||||||
|
* random value.
|
||||||
|
* - Invalid tests: Multiplication result out of range if possible for each
|
||||||
|
* boundary and random value.
|
||||||
|
*
|
||||||
* Steps:
|
* Steps:
|
||||||
* - Call the static analysis arithmetic APIs. Pass in valid values and verify
|
* - Call the static analysis arithmetic APIs. Pass in valid values and verify
|
||||||
* correct return.
|
* correct return.
|
||||||
|
|||||||
Reference in New Issue
Block a user