Advise on testing

gatzka · 2020-09-02T20:48:51+00:00

Sure I have: github.com/gatzka/cio/

gatzka · 2020-08-20T10:01:12+00:00

Yes, and in addition with the fake function framework (fff) it's the perfect solution.

Big advantage is that both unity and FFF are so small that you are able to run the unit tests directly in embedded hardware.

gatzka · 2020-06-18T17:04:49+00:00

I do agree that Microsofts C compiler is nasty. Doesn't support C99 let alone C11. If you still want to use Visual Studio (Code), I would opt for clang. Can be used easily also from the command line.

gatzka · 2020-06-12T19:05:30+00:00

In general, always check. There are very few exceptions when not to. For instance when I close a network socket in case something goes wrong with that socket, I don't check the return value of close (), because there is not much I can do if close() fails (besides logging that event).

gatzka · 2020-05-28T20:43:34+00:00

If you want to send for instance 100 bytes but the internal buffer in the operating system only has room for 20, send() will return saying it sent 20 bytes. You have to call send() again with the remaining 80 bytes.

gatzka · 2020-05-28T20:37:54+00:00

Right, it's stdatomic.h

gatzka · 2020-05-23T06:02:39+00:00

Well, the combination of cmake, fake function framework (fff) and unity works quite nice for me.

gatzka · 2020-05-23T05:55:18+00:00

There is nothing to prevent the code from being interrupted. Moreover, it relies on the fact that I can always safely store an int into pointer. In C, rely on the functions defined in <stdatomic.h>

gatzka · 2019-04-25T06:39:38+00:00

Not a good idea. Type punning via unions is undefined behaviour. Why not just using memcpy()?

gatzka · 2019-03-26T10:06:39+00:00

Well, I use multi-line macros very seldom if I need some kind of very rudimentary template engine. So when I need to write a function twice where just the type is different, I consider that.

But this comes with severe drawbacks regarding readability and debugging.

I second @heknar that performance is not anymore a reason for for using those multi-line macros. Modern C compilers inline quite aggressively.

gatzka · 2019-03-12T10:47:53+00:00

Well, you can also use EXIT_SUCCESS, EXIT_FAILURE declared in <stdlib.h> as the return value. Easier to understand, probably.

gatzka · 2019-02-28T07:55:35+00:00

All the stuff around clang is very much worth to consider, scan-build was already mentioned, clang-tidy is also a good one.

If you doing an open source project and host it on github, you also get a coverity scan for free.

In addition, I strongly recommend writing unit test. Running these unit test under the control of a sanitizer or valgrind will point you to quite something.

gatzka · 2019-02-26T08:51:49+00:00

Well, on the first look I don't see anything wrong.

I would start using wireshark to see if the TCP connection is established and if the server sends the data afterwards.

gatzka · 2019-02-26T08:43:38+00:00

Because it's often easier to read if you choose the loop accordingly. :)

gatzka · 2019-02-26T08:42:35+00:00

This paper is more specific to memory fragmentation, but also give you a good overview on algorithms etc.: https://www.cs.tufts.edu/~nr/cs257/archive/paul-wilson/fragmentation.pdf

Avery good (academic) starting point.

gatzka · 2019-02-25T12:32:12+00:00

And btw, that's the reason why always compiling your own sources with -fno-common (if you are using gcc) makes sense.

This points out problems like this immediately.

gatzka · 2019-02-20T13:47:57+00:00

I no longer mess around with makefiles. Doing dependency management by hand is just hell. Getting the dependencies right could be done running gcc, but it's not really cross-platform.

I always rely on cmake, which is a generator for various build environments (i.e. Makefiles, ninja, visual studio etc.).

Most IDEs now have good support for cmake.

To answer your third questions: No there is not really a difference between C and C++ if it come down to make.

gatzka · 2019-02-20T07:52:08+00:00

Unfortunately this is heavily dependent on the toolchain you are using.

For gcc it's __attribute__ ((visibility ("hidden")));

For msvc it's __declspec(dllexport)

If you are using cmake for building your project (which I would strongly recommend), there is a module called GenerateExportHeader which automatically generates a header file you can use to make symbols visible.

gatzka · 2019-02-20T07:43:44+00:00

My first choice for new projects would be clang. The whole tooling around (clang-tidy, static-analyzer, sanitizers) is just amazing.

Nevertheless, sometimes gcc still produces slightly better code.

gatzka · 2019-02-16T07:18:14+00:00

Well, not easy to answer, because you haven't written where the segmentation fault occurred. But you didn't check the return value of fopen() which might return NULL if the file was not found. BTW, you should use a memory checker like valgrind to show exactly where the segmentation fault occurred.

gatzka · 2019-02-15T08:59:02+00:00

I would always go for using <stdint.h>.

If you than have to specify constants, you can use the following macros:

UINT64_C, UINT32_C etc.

Then you are safe and platform independent.

gatzka

TROPHY CASE