I am testing STM32F103C6 developing board and I want to use TIMx_CNT value in main function like this.
int main(void)
{
while(1)
{
if(TIM2_CNT<500)
{
GPIO_SetBits(GPIOA, GPIO_Pin_4);
} else {
GPIO_ResetBits(GPIOA, GPIO_Pin_4);
}
}
}
Is this possible?
Thanks.
Yes, it's possible. Assuming that you have CMSIS compatible headers included, you need to write TIM2->CNT (instead of TIM2_CNT). Other peripherals follow the same notation.
But for coding style consistency, if you're using ST's HAL (or Cube) libraries, you may want to prefer to use the functions provided by these libraries instead of direct register access, unless there are significant performance benefits.
Is there any way, using static analysis tools(I'm using Codesonar now), to detect unreleased lock problems (something like unreleased semaphores) in the following program?（The comment part marked by arrows）
The project is a multi-task system using Round-robin scheduling, where new_request() is an interrupt task comes randomly and send_buffer() is another period task.
In real case, get_buffer() and send_buffer() are various types of wrappers, which contains many call layers until actual lock/unlock process. So I can't simply specify get_buffer() as lock function in settings of static analysis tool.
int bufferSize = 0; // say max size is 5
// random task
void new_request()
{
int bufferNo = get_buffer(); // wrapper
if (bufferNo == -1)
{
return; // buffer is full
}
if (check_something() == OK)
{
add_to_sendlist(bufferNo); // for asynchronous process of send_buffer()
}
else // bad request
{
// ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
// There should be clear_buffer placed here
// but forgotten. Eventually the buffer will be
// full and won't be cleared since 5th bad request comes.
// ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
do_nothing();
// clear_buffer(bufferNo);
}
}
int get_buffer()
{
if(bufferSize < 5)
{
bufferSize++;
return bufferSize;
}
else
{
wait_until_empty(); // wait until someone is sent by send_buffer()
return -1;
}
}
// clear specifiled one in buffer
void clear_buffer(int bufferNo)
{
delete(bufferNo)
bufferSize--;
}
// period task
void send_buffer()
{
int sent = send_1st_stuff_in_list();
clear_buffer(sent);
}
yoyozi - Fair disclosure: I'm an engineer at GrammaTech who works on CodeSonar.
First some general things. The relevant parts of the manual for this are on the page: codesonar/doc/html/C_Module/LibraryModels/ConcurrencyModelsLocks.html. Especially the bottom of the page on Resolving Lock Operation Identification Problems.
Based on your comments, I think you have already read this, since you address setting the names in the configuration settings.
So then the question is how many different wrappers do you have? If it is only a few, then the settings in the configuration file are the way to go. If there are many, that gets tedious. And if there are very many it becomes practically impossible.
So knowing some estimate for how many wrapper sets you have would help.
Even with the wrappers accounted for, it may be that the deadlock and race detectors aren't quite what you need for your problem.
If I understand your issue correctly, you have a queue with limited space, and by accident malformed items don't get cleaned out of the queue, and so the queue gets full and that stalls all processing. While you may have multiple threads involved in this implementation, the issue itself would still be a problem in a basically serial setting.
The best way to work with an issue like this is to try and make a simpler example that displays the same core problem. If you can do this in a way that can be shared with GrammaTech, we can work with you on ways to adjust settings or maybe provide hints to the analysis so it can find this issue.
If you would like to talk about this in more detail, and with prodetction against public disclosure of your code, please contact us at support_at_grammatech_dot_com, where the at and dot should be replaced as needed to make a well formed email address.
I'm using ASF4 API hal_timer for a ARM Cortex M4. I'm using the timer driver to timing a data sequence.
Why does no reset function exist? I'm using the timer on a TIMER_TASK_ONE_SHOT mode and want to reset it when ever I need to.
I thought a simple
timer_start(&TIMER_0);
timer_stop(&TIMER_0);
would do the trick but does not seem to work.
Is it necessary to re-initialize the timer for each timing event?
I'm probably missing something obvious. Am I approaching this problem incorrectly reason being why the method timer_reset() doesn't exist?
I have no experience of this API, but looking at the documentation it is apparent that a single timer can have multiple tasks on different periods, so resetting TIMER_0 makes little semantic sense; rather you need to reset the individual timer task attached to the timer - of which there may be more than one.
From the documentation (which is poor and contains errors), and the source code which is more reliable:
timer_task_instance.time_label = TIMER_0.time ;
where the timer_task_instance is the struct timer_task instance you want to reset. This sets the start time to the current time.
Probably best to wrap that in a function:
// Restart current interval, return interval.
uint32_t timer_restart( struct timer_descriptor* desc, struct timer_task* tsk )
{
tsk->time_label = desc->time
return tsk->interval ;
}
Then:
timer_restart( &TIMER_0, &timer_task_instance ) ;
Assuming you're using the (edited) example from the ASF4 Reference Manual:
/* TIMER_0 example */
static struct timer_task TIMER_0_task;
static void TIMER_0_task_cb(const struct timer_task *const timer_task)
{
// task you want to delay using non-existent reset function.
}
void TIMER_0_example(void)
{
TIMER_0_task.interval = 100;
TIMER_0_task.cb = TIMER_0_task_cb;
TIMER_0_task.mode = TIMER_TASK_ONE_SHOT;
timer_add_task(&TIMER_0, &TIMER_0_task);
timer_start(&TIMER_0);
}
Instead of resetting, which isn't supported by the API, you could use:
timer_remove_task(&TIMER_0, &TIMER_0_task);
timer_add_task(&TIMER_0, &TIMER_0_task);
which will effectively restart the delay associated with TIMER_0_task.
Under the hood, timer tasks are maintained as an ordered list, in order of when each task will expire, and using the functions provided by the API maintains the list order.
I am new to gmock, so I want to know how can I stub simple C function called in a function under test for Unit Testing.
Example:
int func(int a)
{
boolean find;
// Some code
find = func_1();
return find;
}
I have searched about gmock and in my understanding gmock does not provide functionality to stub simple C functions, therefore I want to ask does gmock provides functionality to mock or stub func_1?
If not how can I stub func_1 manually in my test code without changing source code? I am using google test framework for unit testing.
Thanks.
This is another answer of mine to this question. In the two years that passed since the first answer, I came to understand that GMock is simply the wrong framework for mocking C functions. In situations where you have a lot of functions to mock, my previously posted answer is simply too cumbersome. The reason is that GMock uses Object Seams to replace production code with mock code. This relies on polymorphic classes, which don't exist in C.
Instead, to mock C functions, you should use Link Seams, which replace the production code with the mock code at link time. Several frameworks exist for this purpose, but my favorite one is the Fake Function Framework (FFF). Check it out, it's a lot simpler than GMock. It also works perfectly well in C++ applications.
For the interested, here is a good article by Michael Feathers about the different seam types.
I found myself in the same situation lately. I had to write unit tests for
libraries written in C, which in turn had dependencies to other libraries also written in C. So I wanted to mock all function calls of dependencies
using gmock. Let me explain my approach by an example.
Assume the code to be tested (library A) calls a function from another library, lib_x_function():
lib_a_function()
{
...
retval = lib_x_function();
...
}
So, I want to mock the library X. Therefore I write an interface class and a
mock class in a file lib_x_mock.h:
class LibXInterface {
public:
virtual ~LibXInterface() {}
virtual int lib_x_function() = 0;
}
class LibXMock : public LibXInterface {
public:
virtual ~LibXMock() {}
MOCK_METHOD0(lib_x_function, int());
}
Additionally I create a source file (say, lib_x_mock.cc), that defines a stub
for the actual C function. This shall call the mock method. Note the extern
reference to the mock object.
#include lib_x.h
#include lib_x_mock.h
extern LibXMock LibXMockObj; /* This is just a declaration! The actual
mock obj must be defined globally in your
test file. */
int lib_x_function()
{
return LibXMockObj.lib_x_function();
}
Now, in the test file, which tests the library A, I must define the mock object
globally, so that it is both reachable within your tests and from
lib_x_mock.cc. This is lib_a_tests.cc:
#include lib_x_mock.h
LibXMock LibXMockObj; /* This is now the actual definition of the mock obj */
...
TEST_F(foo, bar)
{
EXPECT_CALL(LibXMockObj, lib_x_function());
...
}
This approach works perfectly for me, and I have dozens of tests and several
mocked libraries. However, I have a few doubts if it is ok to create a
global mock object - I asked this in a separate question and still wait for answers. Besides this I'm happy with the solution.
UPDATE: The problem about the global object can be easily remedied by creating the object e.g. in the constructor of the test fixture, and just storing a pointer to that object in a global variable.
However, also note my alternative answer to this question, that I just posted.
I was looking already a long time for a solution to mock legacy c-functions with googleMock without changing existing code and last days I found the following really great article: https://www.codeproject.com/articles/1040972/using-googletest-and-googlemock-frameworks-for-emb
Today I wrote my first unit test for c-functions using gmock and took as example two functions from the bcm2835.c library (http://www.airspayce.com/mikem/bcm2835/) for raspberry Pi programming:
Here is my solution: I'm using the gcc 4.8.3. under Eclipse and Windows. Be Aware to set the Compiler option -std=gnu++11.
Here are my functions to be tested
int inits(void);
void pinMode(uint8_t pin, uint8_t mode);
int inits(){
return bcm2835_init();
}
void pinMode(uint8_t pin, uint8_t mode){
bcm2835_gpio_fsel(pin, mode);
}
Includes and defines for unit testing with googleTest / googleMock
// MOCKING C-Functions with GMOCK :)
#include <memory>
#include "gtest/gtest.h"
#include "gmock/gmock.h"
using namespace ::testing;
using ::testing::Return;
Mock BCM2835Lib functions
class BCM2835Lib_MOCK{
public:
virtual ~BCM2835Lib_MOCK(){}
// mock methods
MOCK_METHOD0(bcm2835_init,int());
MOCK_METHOD2(bcm2835_gpio_fsel,void(uint8_t,uint8_t));
};
Create a TestFixture
class TestFixture: public ::testing::Test{
public:
TestFixture(){
_bcm2835libMock.reset(new ::testing::NiceMock<BCM2835Lib_MOCK>());
}
~TestFixture(){
_bcm2835libMock.reset();
}
virtual void SetUp(){}
virtual void TearDown(){}
// pointer for accessing mocked library
static std::unique_ptr<BCM2835Lib_MOCK> _bcm2835libMock;
};
Instantiate mocked lib functions
// instantiate mocked lib
std::unique_ptr<BCM2835Lib_MOCK> TestFixture::_bcm2835libMock;
Fake lib functions to connect Mocks with the c-functions
// fake lib functions
int bcm2835_init(){return TestFixture::_bcm2835libMock->bcm2835_init();}
void bcm2835_gpio_fsel(uint8_t pin, uint8_t mode){TestFixture::_bcm2835libMock->bcm2835_gpio_fsel(pin,mode);}
Create unit testing class for BCM2835 from TestFixture
// create unit testing class for BCM2835 from TestFixture
class BCM2835LibUnitTest : public TestFixture{
public:
BCM2835LibUnitTest(){
// here you can put some initializations
}
};
Write the Tests using googleTest and googleMock
TEST_F(BCM2835LibUnitTest,inits){
EXPECT_CALL(*_bcm2835libMock,bcm2835_init()).Times(1).WillOnce(Return(1));
EXPECT_EQ(1,inits()) << "init must return 1";
}
TEST_F(BCM2835LibUnitTest,pinModeTest){
EXPECT_CALL(*_bcm2835libMock,bcm2835_gpio_fsel( (uint8_t)RPI_V2_GPIO_P1_18
,(uint8_t)BCM2835_GPIO_FSEL_OUTP
)
)
.Times(1)
;
pinMode((uint8_t)RPI_V2_GPIO_P1_18,(uint8_t)BCM2835_GPIO_FSEL_OUTP);
}
Results :)
[----------] 2 tests from BCM2835LibUnitTest
[ RUN ] BCM2835LibUnitTest.inits
[ OK ] BCM2835LibUnitTest.inits (0 ms)
[ RUN ] BCM2835LibUnitTest.pinModeTest
[ OK ] BCM2835LibUnitTest.pinModeTest (0 ms)
[----------] 2 tests from BCM2835LibUnitTest (0 ms total)
Hope it will help :) - for me this is a really working solution.
You can use the Cutie library to mock C function GoogleMock style.
There's a full sample in the repo, but just a taste:
INSTALL_MOCK(close);
CUTIE_EXPECT_CALL(fclose, _).WillOnce(Return(i));
I had a similar case in a project I was unit-testing. My solution was to create two make files, one for production and one for testing.
If the function func_1() is definded in the header a.h, and implemented in a.cpp, then for testing you can add a new source file a_testing.cpp, that will implement all the functions in a.h as a stub.
For unittesting, just compile and link with a_testing.cpp instead of a.cpp and the tested code will call your stub.
In a_testing.cpp you can then forward the call to a gmock object that will set expectations and actions as usual based on the state and paramteres.
I know it's not perfect, but it works ans solve the problem without changing production code or interfaces at all.
In each UT we are trying to verify a specific behavior.
You should fake something when it's very hard/impossible(we need to isolate our unit)/spend a lot of time(running time..) to simulate a specific behavior.
Using a 'C' function in the explicit way means that the function is apart of your unit(therefore you shouldn't mock it..). In this answer I explain the initiative to test the method as is(in the edit..). In my opinion you should call func with the parameters which cause func_1 to simulate the behavior you want to verify.
GMock is based on compilation fake(macros), therefore you cannot do such a thing. To fake 'C' methods you have to use a different tools such as Typemock Isolator++.
If you don't want to use Isolator++, then you should refactor your method; Change func to func(int a, <your pointer the function>) and then use the pointer instead of func_1.
My chart in this answer might help to decide the way to handle your case.
This might not totally fit your case, but if you find yourself writing C code that needs to be stubbed (e.g. you want to stub some I/O connection), you could use function pointers.
So let's say you have a header and source file with the following function declaration and definition:
some_file.h
// BEGIN SOME_FILE_H
#ifndef SOME_FILE_H
#define SOME_FILE_H
#include <stdbool.h>
bool func_1(void);
#endif // SOME_FILE_H
// END SOME_FILE_H
some_file.c
// BEGIN SOME_FILE_C
#include "some_file.h"
bool func_1(void) {
return true;
}
// END SOME_FILE_C
Now, if you would like to stub this method, all you have to do is convert this method into a function pointer.
You will also have to adjust the .c file, since we changed the function and made it a function pointer.
some_file.h
// BEGIN SOME_FILE_H
#ifndef SOME_FILE_H
#define SOME_FILE_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdbool.h>
extern bool (*func_1)(void);
#ifdef __cplusplus
}
#endif
#endif // SOME_FILE_H
// END SOME_FILE_H
some_file.c
// BEGIN SOME_FILE_C
#include "some_file.h"
// Make the method static, so that it cannot be accessed anywhere else except in this file
static bool func_1_Impl(void) {
return true;
}
bool (*func_1)(void) = func_1_Impl;
// END SOME_FILE_C
You don't have to adjust the function calls anywhere else, since func_1 will simply be redirected to func_1_Impl.
Now for stubbing this method:
In your *_test.cc file (or whatever you call your test file), you can create a mock class with the same interface as some_file.h.
You can then overwrite the function pointer with the defined mock function.
some_file_test.cc
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "some_file.h"
#include "header_where_func_is_declared.h"
using ::testing::AtLeast;
class SomeFile {
public:
virtual bool func1() = 0;
};
class MockSomeFile : SomeFile {
public:
MOCK_METHOD(bool, func1, (), (override));
};
TEST(Func1Test, ShouldMockStuff) {
// Arrange
auto expected = 0; // or whatever the expected result is
// Define the mock object to be used
static MockSomeFile mock;
// The important part: Overwrite the function pointer (with a lambda function)
func_1 = []() { return mock.func1(); };
// Define the call expectations
EXPECT_CALL(mock, func1)
.Times(AtLeast(1));
// Act
auto actual = func();
// Assert
EXPECT_EQ(expected, actual);
}
This test should pass, showing that the mocking worked.
You can also check, whether the test will fail, if you change the EXPECT_CALL call, e.g. set .Times(AtLeast(2)).
Note: You might see that the adjusted test passed with AtLeast(2), although this is wrong. You should still see the correct error message in the console.
I hope this helps you and everyone else who has a similar problem!
I have a DLL which contains many large (1000+ line) functions. This code has lots of complex logic which I want to ensure doesn't get broken when its maintained so I created a test harness which dynamically loads this DLL and calls its API.
I would like to know a nice way of being able to test which branches of the code where hit within this API from my test harness. The only way I can think of doing this is as follows:
// Pseudo test code
void doTest()
{
loadDllToBeTested();
dll_api_function_1();
assert( dll_api_function_1_branches.branch1Hit == true );
unloadDllToBeTested();
}
// Real api in the C dll
struct dll_api_function_1_branches
{
bool branch1Hit;
}
dll_api_function_1_branches g_dll_api_function_1_branches;
int private_func1()
{
printf("Doing my private stuff\n");
return 1;
}
void dll_api_function_1(void)
{
if ( private_func1() )
{
printf("doing some stuff\n");
dll_api_function_1_branches.branch1Hit = true; // so the test code can check if we got here :(
}
else
{
printf("doing some other stuff\n");
}
// tons of other logic and branching...
}
Which is basically have a struct per function which has values set when certain branches are reached within the function. There would be a global exported instance of this struct which the test code would have to init to zero and then check after calling the API.
Also note that I'm using Visual Studio so tools like gcov can't be used here.
The LLVM project mentions the KLEE tool, which helps creating test cases to exercise all paths (and find bugs in the process). Some of it is strongly Unix-oriented, and it is a current research project (rough edges, some assembly required, and the other disclaimers).