readme + ownership issues
This commit is contained in:
Rens Pastoor
@@ -1 +0,0 @@
|
|||||||
main
|
|
||||||
Binary file not shown.
@@ -1,20 +0,0 @@
|
|||||||
NAME=main
|
|
||||||
|
|
||||||
FILES=main.c
|
|
||||||
|
|
||||||
CC=gcc
|
|
||||||
|
|
||||||
SYMBOLS=-g -O0 -std=c99 -Wall -Werror -Wextra -pedantic -Wno-unused-parameter
|
|
||||||
|
|
||||||
.PHONY: clean
|
|
||||||
|
|
||||||
all: product
|
|
||||||
|
|
||||||
product: Makefile $(FILES)
|
|
||||||
$(CC) $(INC_DIRS) $(SYMBOLS) $(FILES) -o $(NAME)
|
|
||||||
|
|
||||||
run: product
|
|
||||||
./$(NAME)
|
|
||||||
|
|
||||||
clean:
|
|
||||||
rm -f $(NAME)
|
|
||||||
@@ -1,256 +0,0 @@
|
|||||||
#include <stdbool.h>
|
|
||||||
#include <stdint.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <unistd.h>
|
|
||||||
|
|
||||||
/*---------------------------------------------------------------*/
|
|
||||||
#define BIKE_COMPUTER_SIMULATOR_VALUE_MIN_SPEED (27)
|
|
||||||
#define BIKE_COMPUTER_SIMULATOR_VALUE_MAX_SPEED (30)
|
|
||||||
|
|
||||||
#define BIKE_COMPUTER_SIMULATOR_VALUE_MIN_POWER (150)
|
|
||||||
#define BIKE_COMPUTER_SIMULATOR_VALUE_MAX_POWER (200)
|
|
||||||
|
|
||||||
#define BIKE_COMPUTER_SIMULATOR_VALUE_MIN_HEART_RATE (130)
|
|
||||||
#define BIKE_COMPUTER_SIMULATOR_VALUE_MAX_HEART_RATE (140)
|
|
||||||
|
|
||||||
#define BIKE_COMPUTER_SIMULATOR_VALUE_MIN_CADENCE (88)
|
|
||||||
#define BIKE_COMPUTER_SIMULATOR_VALUE_MAX_CADENCE (98)
|
|
||||||
|
|
||||||
#define BIKE_STORE_MAX_NUMBER_MEASUREMENTS (32)
|
|
||||||
|
|
||||||
typedef enum {
|
|
||||||
BIKE_SPEED,
|
|
||||||
BIKE_HEART_RATE,
|
|
||||||
BIKE_CADENCE,
|
|
||||||
BIKE_POWER
|
|
||||||
} bike_data_type;
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
uint16_t speed;
|
|
||||||
uint16_t heart_rate;
|
|
||||||
uint16_t cadence;
|
|
||||||
uint16_t power;
|
|
||||||
} bike_store_measurement;
|
|
||||||
|
|
||||||
bike_store_measurement bike_store_array[BIKE_STORE_MAX_NUMBER_MEASUREMENTS] = {
|
|
||||||
{ 0, },
|
|
||||||
};
|
|
||||||
uint16_t bike_store_number_of_measurements_present = 0;
|
|
||||||
|
|
||||||
/*---------------------------------------------------------------*/
|
|
||||||
uint16_t
|
|
||||||
bike_computer_simulator_get_random_value(uint16_t min_range, uint16_t max_range)
|
|
||||||
{
|
|
||||||
uint16_t range = (max_range - min_range);
|
|
||||||
|
|
||||||
uint16_t random_value = min_range + (rand() % range);
|
|
||||||
|
|
||||||
return random_value;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bike_measure_speed_in_kmh()
|
|
||||||
{
|
|
||||||
return bike_computer_simulator_get_random_value(
|
|
||||||
BIKE_COMPUTER_SIMULATOR_VALUE_MIN_SPEED,
|
|
||||||
BIKE_COMPUTER_SIMULATOR_VALUE_MAX_SPEED);
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bike_measure_power_in_watt()
|
|
||||||
{
|
|
||||||
return bike_computer_simulator_get_random_value(
|
|
||||||
BIKE_COMPUTER_SIMULATOR_VALUE_MIN_POWER,
|
|
||||||
BIKE_COMPUTER_SIMULATOR_VALUE_MAX_POWER);
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bike_measure_cadence_in_rpm()
|
|
||||||
{
|
|
||||||
return bike_computer_simulator_get_random_value(
|
|
||||||
BIKE_COMPUTER_SIMULATOR_VALUE_MIN_CADENCE,
|
|
||||||
BIKE_COMPUTER_SIMULATOR_VALUE_MAX_CADENCE);
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bike_measure_heart_rate_in_bpm()
|
|
||||||
{
|
|
||||||
return bike_computer_simulator_get_random_value(
|
|
||||||
BIKE_COMPUTER_SIMULATOR_VALUE_MIN_HEART_RATE,
|
|
||||||
BIKE_COMPUTER_SIMULATOR_VALUE_MAX_HEART_RATE);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*---------------------------------------------------------------*/
|
|
||||||
uint16_t bike_store_get_maximum_bike_store_size()
|
|
||||||
{
|
|
||||||
return BIKE_STORE_MAX_NUMBER_MEASUREMENTS;
|
|
||||||
}
|
|
||||||
|
|
||||||
void bike_store_add_measurement(bike_store_measurement value)
|
|
||||||
{
|
|
||||||
if (bike_store_number_of_measurements_present >=
|
|
||||||
bike_store_get_maximum_bike_store_size())
|
|
||||||
{
|
|
||||||
bike_store_number_of_measurements_present = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
bike_store_array[bike_store_number_of_measurements_present] = value;
|
|
||||||
bike_store_number_of_measurements_present++;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bike_store_get_number_of_measurements_present()
|
|
||||||
{
|
|
||||||
return bike_store_number_of_measurements_present;
|
|
||||||
}
|
|
||||||
|
|
||||||
bike_store_measurement bike_store_get_measurement(uint16_t index_position)
|
|
||||||
{
|
|
||||||
bike_store_measurement value = bike_store_array[index_position];
|
|
||||||
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*---------------------------------------------------------------*/
|
|
||||||
uint16_t bike_math_get_value_for_data_type(
|
|
||||||
bike_store_measurement measurement, bike_data_type data_type)
|
|
||||||
{
|
|
||||||
uint16_t value = 0;
|
|
||||||
|
|
||||||
if (data_type == BIKE_CADENCE)
|
|
||||||
{
|
|
||||||
value = measurement.cadence;
|
|
||||||
}
|
|
||||||
else if (data_type == BIKE_SPEED)
|
|
||||||
{
|
|
||||||
value = measurement.speed;
|
|
||||||
}
|
|
||||||
else if (data_type == BIKE_HEART_RATE)
|
|
||||||
{
|
|
||||||
value = measurement.heart_rate;
|
|
||||||
}
|
|
||||||
else if (data_type == BIKE_POWER)
|
|
||||||
{
|
|
||||||
value = measurement.power;
|
|
||||||
}
|
|
||||||
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bike_math_calculate_min_value(bike_data_type data_type)
|
|
||||||
{
|
|
||||||
uint16_t number_of_measurements =
|
|
||||||
bike_store_get_number_of_measurements_present();
|
|
||||||
|
|
||||||
uint16_t min_value = UINT16_MAX;
|
|
||||||
|
|
||||||
for (uint16_t index_position = 0; index_position < number_of_measurements;
|
|
||||||
index_position++)
|
|
||||||
{
|
|
||||||
bike_store_measurement measurement =
|
|
||||||
bike_store_get_measurement(index_position);
|
|
||||||
uint16_t value =
|
|
||||||
bike_math_get_value_for_data_type(measurement, data_type);
|
|
||||||
if (value < min_value)
|
|
||||||
{
|
|
||||||
min_value = value;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return min_value;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bike_math_calculate_max_value(bike_data_type data_type)
|
|
||||||
{
|
|
||||||
uint16_t number_of_measurements =
|
|
||||||
bike_store_get_number_of_measurements_present();
|
|
||||||
|
|
||||||
uint16_t max_value = 0;
|
|
||||||
|
|
||||||
for (uint16_t index_position = 0; index_position < number_of_measurements;
|
|
||||||
index_position++)
|
|
||||||
{
|
|
||||||
bike_store_measurement measurement =
|
|
||||||
bike_store_get_measurement(index_position);
|
|
||||||
uint16_t value =
|
|
||||||
bike_math_get_value_for_data_type(measurement, data_type);
|
|
||||||
if (value > max_value)
|
|
||||||
{
|
|
||||||
max_value = value;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return max_value;
|
|
||||||
}
|
|
||||||
|
|
||||||
uint16_t bike_math_calculate_average_value(bike_data_type data_type)
|
|
||||||
{
|
|
||||||
uint16_t number_of_measurements =
|
|
||||||
bike_store_get_number_of_measurements_present();
|
|
||||||
|
|
||||||
if (number_of_measurements == 0)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
uint16_t average = 0;
|
|
||||||
uint32_t sum = 0;
|
|
||||||
|
|
||||||
for (uint16_t index_position = 0; index_position < number_of_measurements;
|
|
||||||
index_position++)
|
|
||||||
{
|
|
||||||
bike_store_measurement measurement =
|
|
||||||
bike_store_get_measurement(index_position);
|
|
||||||
uint16_t value =
|
|
||||||
bike_math_get_value_for_data_type(measurement, data_type);
|
|
||||||
sum += value;
|
|
||||||
}
|
|
||||||
|
|
||||||
average = sum / number_of_measurements;
|
|
||||||
|
|
||||||
return average;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*---------------------------------------------------------------*/
|
|
||||||
int main(int argc, char* argv[])
|
|
||||||
{
|
|
||||||
bike_store_measurement measurement;
|
|
||||||
uint16_t min = 0, max = 0, average = 0;
|
|
||||||
bike_data_type data_type;
|
|
||||||
|
|
||||||
while (true)
|
|
||||||
{
|
|
||||||
measurement.speed = bike_measure_speed_in_kmh();
|
|
||||||
measurement.cadence = bike_measure_cadence_in_rpm();
|
|
||||||
measurement.heart_rate = bike_measure_heart_rate_in_bpm();
|
|
||||||
measurement.power = bike_measure_power_in_watt();
|
|
||||||
|
|
||||||
bike_store_add_measurement(measurement);
|
|
||||||
|
|
||||||
data_type = BIKE_SPEED;
|
|
||||||
min = bike_math_calculate_min_value(data_type);
|
|
||||||
max = bike_math_calculate_max_value(data_type);
|
|
||||||
average = bike_math_calculate_average_value(data_type);
|
|
||||||
printf("SPEED:\t\t%d, average = %d, min = %d, max = %d [km/h]\n",
|
|
||||||
measurement.speed, average, min, max);
|
|
||||||
|
|
||||||
data_type = BIKE_CADENCE;
|
|
||||||
min = bike_math_calculate_min_value(data_type);
|
|
||||||
max = bike_math_calculate_max_value(data_type);
|
|
||||||
average = bike_math_calculate_average_value(data_type);
|
|
||||||
printf("CADENCE:\t%d, average = %d, min = %d, max = %d [rpm]\n",
|
|
||||||
measurement.cadence, average, min, max);
|
|
||||||
|
|
||||||
data_type = BIKE_HEART_RATE;
|
|
||||||
min = bike_math_calculate_min_value(data_type);
|
|
||||||
max = bike_math_calculate_max_value(data_type);
|
|
||||||
average = bike_math_calculate_average_value(data_type);
|
|
||||||
printf("HEART-RATE:\t%d, average = %d, min = %d, max = %d [hrm]\n",
|
|
||||||
measurement.heart_rate, average, min, max);
|
|
||||||
|
|
||||||
data_type = BIKE_POWER;
|
|
||||||
min = bike_math_calculate_min_value(data_type);
|
|
||||||
max = bike_math_calculate_max_value(data_type);
|
|
||||||
average = bike_math_calculate_average_value(data_type);
|
|
||||||
printf("POWER:\t\t%d, average = %d, min = %d, max = %d [watt]\n",
|
|
||||||
measurement.power, average, min, max);
|
|
||||||
printf("\n");
|
|
||||||
|
|
||||||
sleep(1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,92 +0,0 @@
|
|||||||
# t-oer-prc2-CBDB
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
## Getting started
|
|
||||||
|
|
||||||
To make it easy for you to get started with GitLab, here's a list of recommended next steps.
|
|
||||||
|
|
||||||
Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
|
|
||||||
|
|
||||||
## Add your files
|
|
||||||
|
|
||||||
- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
|
|
||||||
- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
|
|
||||||
|
|
||||||
```
|
|
||||||
cd existing_repo
|
|
||||||
git remote add origin https://git.fhict.nl/technology/t-oer-prc2-cbdb.git
|
|
||||||
git branch -M main
|
|
||||||
git push -uf origin main
|
|
||||||
```
|
|
||||||
|
|
||||||
## Integrate with your tools
|
|
||||||
|
|
||||||
- [ ] [Set up project integrations](https://git.fhict.nl/technology/t-oer-prc2-cbdb/-/settings/integrations)
|
|
||||||
|
|
||||||
## Collaborate with your team
|
|
||||||
|
|
||||||
- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
|
|
||||||
- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
|
|
||||||
- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
|
|
||||||
- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
|
|
||||||
- [ ] [Automatically merge when pipeline succeeds](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
|
|
||||||
|
|
||||||
## Test and Deploy
|
|
||||||
|
|
||||||
Use the built-in continuous integration in GitLab.
|
|
||||||
|
|
||||||
- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
|
|
||||||
- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
|
|
||||||
- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
|
|
||||||
- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
|
|
||||||
- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
|
|
||||||
|
|
||||||
***
|
|
||||||
|
|
||||||
# Editing this README
|
|
||||||
|
|
||||||
When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thank you to [makeareadme.com](https://www.makeareadme.com/) for this template.
|
|
||||||
|
|
||||||
## Suggestions for a good README
|
|
||||||
Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
|
|
||||||
|
|
||||||
## Name
|
|
||||||
Choose a self-explaining name for your project.
|
|
||||||
|
|
||||||
## Description
|
|
||||||
Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
|
|
||||||
|
|
||||||
## Badges
|
|
||||||
On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
|
|
||||||
|
|
||||||
## Visuals
|
|
||||||
Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
|
|
||||||
|
|
||||||
## Installation
|
|
||||||
Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
|
|
||||||
|
|
||||||
## Usage
|
|
||||||
Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
|
|
||||||
|
|
||||||
## Support
|
|
||||||
Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
|
|
||||||
|
|
||||||
## Roadmap
|
|
||||||
If you have ideas for releases in the future, it is a good idea to list them in the README.
|
|
||||||
|
|
||||||
## Contributing
|
|
||||||
State if you are open to contributions and what your requirements are for accepting them.
|
|
||||||
|
|
||||||
For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
|
|
||||||
|
|
||||||
You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
|
|
||||||
|
|
||||||
## Authors and acknowledgment
|
|
||||||
Show your appreciation to those who have contributed to the project.
|
|
||||||
|
|
||||||
## License
|
|
||||||
For open source projects, say how it is licensed.
|
|
||||||
|
|
||||||
## Project status
|
|
||||||
If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
|
|
||||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,14 +0,0 @@
|
|||||||
Anything that happens. happens,
|
|
||||||
|
|
||||||
Anything that. in happening. causes something
|
|
||||||
else to happen. causes something else to happen,
|
|
||||||
|
|
||||||
Anything that. in happening. causes
|
|
||||||
itself to happen again. happens again,
|
|
||||||
|
|
||||||
It doesn't necessarily do it
|
|
||||||
in chronological order. though,
|
|
||||||
|
|
||||||
|
|
||||||
From: The Hitchhiker's guide to the Galaxy by Douglas Adams,
|
|
||||||
Book five in the trilogy of five: Mostly Harmless,
|
|
||||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,52 +0,0 @@
|
|||||||
[[_TOC_]]
|
|
||||||
|
|
||||||
# Introduction
|
|
||||||
|
|
||||||
In this module you will find an introduction the required tooling and hardware you will need for this course.
|
|
||||||
|
|
||||||
# Setup
|
|
||||||
|
|
||||||
## Linux virtual image
|
|
||||||
|
|
||||||
+ Linux Virtual image for programming environment is available at:
|
|
||||||
+ [www.fhict.nl/docent/downloads/TI/S3/](https://www.fhict.nl/docent/downloads/TI/S3/) (please use the kathara image) This image includes visual studio code setup and kathare (used for networking challenges)
|
|
||||||
+ If you use your own Linux installation you can use (at your own risk!) the script for the required tooling: [link](https://git.fhict.nl/technology/t-sem2-code/blob/master/es2/scripts/install-tooling.sh).
|
|
||||||
+ You can download VMware via [FHICT Studentenplein](https://portal.fhict.nl/Studentenplein/SitePages/Home.aspx) via link `VMware Store`.
|
|
||||||
|
|
||||||
# Information-resources
|
|
||||||
|
|
||||||
## Development environment
|
|
||||||
|
|
||||||
For editing and compiling your code we recommend the following options:
|
|
||||||
|
|
||||||
+ For Arduino and PC code: [Visual Code](https://code.visualstudio.com/) editor with use of the [PlatformIO](https://platformio.org/install/ide?install=vscode). The provided VmWare image has Visual Code already installed and is configured with a number of plugins to support building executables for your PC and Arduino (see the above installation script for details). You can start up Visual Code from a terminal by the command `code .` (don't forget the `.` (point!): it means it will use the current directory as project directory).
|
|
||||||
+ For PC-code: a simple text editor (like [Geany](https://www.geany.org/), [Sublime](https://www.sublimetext.com/), [Vim](http://www.vim.org/), [Emacs](https://www.gnu.org/software/emacs/) and a [terminal](https://www.google.nl/search?q=linux+terminal+tutorial) using the [make](https://linux.die.net/man/1/make) program.
|
|
||||||
+ For building code using a terminal and make see [link](https://www.google.nl/search?q=linux+using+make+terminal).
|
|
||||||
+ For Arduino code: [Arduino IDE](https://www.arduino.cc/en/Main/Software). We will however require you to use [header-files](https://www.google.nl/search?q=header+files+in+c).
|
|
||||||
|
|
||||||
+ An online editor to try some basic stuff: [https://www.onlinegdb.com/](https://www.onlinegdb.com/)
|
|
||||||
|
|
||||||
+ Tip: you can install other software in your Linux environment by using [apt-get](https://www.google.nl/search?q=linux+using+apt-get+install).
|
|
||||||
|
|
||||||
## For Windows users
|
|
||||||
|
|
||||||
It is possible, with some effort on your side, to run C-programs on a Windows machine. This is however at your own initiative to install, and your teacher may offer limited support because of the availability of the Linux image.
|
|
||||||
|
|
||||||
### WSL
|
|
||||||
|
|
||||||
An option is to use WSL [Windows Subsystem for Linux(WSL)](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Install the following:
|
|
||||||
|
|
||||||
+ [Ubuntu](https://docs.microsoft.com/en-us/windows/wsl/install-win10) and execute the following command in a terminal:
|
|
||||||
+ `sudo apt-get install -y build-essential make gcc g++`
|
|
||||||
+ [Visual Studio Code](https://code.visualstudio.com/) met de volgende extensies:
|
|
||||||
+ [WSL integratie](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl)
|
|
||||||
+ [PlatformIO](https://marketplace.visualstudio.com/items?itemName=platformio.platformio-ide)
|
|
||||||
+ For onnecting USB devices to your WSL see [Connect-usb](https://learn.microsoft.com/en-us/windows/wsl/connect-usb#install-the-usbipd-win-project)
|
|
||||||
|
|
||||||
### MinGW Gcc compiler
|
|
||||||
|
|
||||||
The other option for c-compiling is [TDM-GCC MinGW Compiler](https://sourceforge.net/projects/tdm-gcc/). Here you have to install make and a gcc compiler.
|
|
||||||
|
|
||||||
# Starting project
|
|
||||||
|
|
||||||
You can use the startingproject in the enclosed folder to test your setup. Content and way of working is explained [here](https://git.fhict.nl/technology/t-oer-prc2/-/blob/master/development-setup/startingProject/README.md).
|
|
||||||
Binary file not shown.
@@ -1,3 +0,0 @@
|
|||||||
!build/
|
|
||||||
build/*
|
|
||||||
!build/.gitkeep
|
|
||||||
@@ -1,27 +0,0 @@
|
|||||||
{
|
|
||||||
// Use IntelliSense to learn about possible attributes.
|
|
||||||
// Hover to view descriptions of existing attributes.
|
|
||||||
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
|
|
||||||
"version": "0.2.0",
|
|
||||||
"configurations": [
|
|
||||||
{
|
|
||||||
"name": "(gdb) Launch",
|
|
||||||
"type": "cppdbg",
|
|
||||||
"request": "launch",
|
|
||||||
"program": "${workspaceFolder}/build/main_test",
|
|
||||||
"args": [],
|
|
||||||
"stopAtEntry": false,
|
|
||||||
"cwd": "${workspaceFolder}",
|
|
||||||
"environment": [],
|
|
||||||
"externalConsole": false,
|
|
||||||
"MIMode": "gdb",
|
|
||||||
"setupCommands": [
|
|
||||||
{
|
|
||||||
"description": "Enable pretty-printing for gdb",
|
|
||||||
"text": "-enable-pretty-printing",
|
|
||||||
"ignoreFailures": true
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
@@ -1,41 +0,0 @@
|
|||||||
PROD_DIR := ./product
|
|
||||||
SHARED_DIR := ./shared
|
|
||||||
TEST_DIR := ./test
|
|
||||||
UNITY_FOLDER=./Unity
|
|
||||||
BUILD_DIR=./build
|
|
||||||
|
|
||||||
PROD_EXEC = main
|
|
||||||
PROD_DIRS := $(PROD_DIR) $(SHARED_DIR)
|
|
||||||
PROD_FILES := $(wildcard $(patsubst %,%/*.c, $(PROD_DIRS)))
|
|
||||||
HEADER_PROD_FILES := $(wildcard $(patsubst %,%/*.h, $(PROD_DIRS)))
|
|
||||||
PROD_INC_DIRS=-I$(PROD_DIR) -I$(SHARED_DIR)
|
|
||||||
|
|
||||||
TEST_EXEC = main_test
|
|
||||||
TEST_DIRS := $(TEST_DIR) $(SHARED_DIR) $(UNITY_FOLDER)
|
|
||||||
TEST_FILES := $(wildcard $(patsubst %,%/*.c, $(TEST_DIRS)))
|
|
||||||
HEADER_TEST_FILES := $(wildcard $(patsubst %,%/*.h, $(TEST_DIRS)))
|
|
||||||
TEST_INC_DIRS=-I$(TEST_DIR) -I$(SHARED_DIR) -I$(UNITY_FOLDER)
|
|
||||||
|
|
||||||
CC=gcc
|
|
||||||
SYMBOLS=-Wall -Werror -g -pedantic -O0 -std=c99
|
|
||||||
TEST_SYMBOLS=$(SYMBOLS) -DTEST
|
|
||||||
|
|
||||||
.PHONY: clean test
|
|
||||||
|
|
||||||
all: $(PROD_EXEC) $(TEST_EXEC)
|
|
||||||
|
|
||||||
$(PROD_EXEC): Makefile $(PROD_FILES) $(HEADER_FILES)
|
|
||||||
$(CC) $(PROD_INC_DIRS) $(TEST_SYMBOLS) $(PROD_FILES) -o $(BUILD_DIR)/$(PROD_EXEC)
|
|
||||||
|
|
||||||
$(TEST_EXEC): Makefile $(TEST_FILES) $(HEADER_FILES)
|
|
||||||
$(CC) $(TEST_INC_DIRS) $(TEST_SYMBOLS) $(TEST_FILES) -o $(BUILD_DIR)/$(TEST_EXEC)
|
|
||||||
|
|
||||||
run: $(PROD_EXEC)
|
|
||||||
@./$(BUILD_DIR)/$(PROD_EXEC)
|
|
||||||
|
|
||||||
test: $(TEST_EXEC)
|
|
||||||
@./$(BUILD_DIR)/$(TEST_EXEC)
|
|
||||||
|
|
||||||
clean:
|
|
||||||
rm -f $(BUILD_DIR)/$(PROD_EXEC)
|
|
||||||
rm -f $(BUILD_DIR)/$(TEST_EXEC)
|
|
||||||
@@ -1,69 +0,0 @@
|
|||||||
# What does this project contain?
|
|
||||||
|
|
||||||
This directory holds an (almost) empty C project.
|
|
||||||
It can be used as a template for your own project.
|
|
||||||
|
|
||||||
It contains of:
|
|
||||||
|
|
||||||
+ a main which is the starting point for you program
|
|
||||||
+ an example of a c and corresponding header file
|
|
||||||
* you have to complete the swap code.
|
|
||||||
+ an example of a unittest
|
|
||||||
|
|
||||||
## Directory structure
|
|
||||||
|
|
||||||
Directory | Purpose
|
|
||||||
---|---
|
|
||||||
product | Holds the main.c file and c-source files that are **only** needed to build the **main** executable.
|
|
||||||
test | Holds all the unit tests that are used are build the **main_test** executable.
|
|
||||||
shared | Holds the files that are used by both the **main** as **main_test** executable. In general these are the c-source files that you wish to unit test.
|
|
||||||
build | Holds the build [artifacts](https://en.wikipedia.org/wiki/Artifact_(software_development): **main** and **main_test**
|
|
||||||
|
|
||||||
|
|
||||||
# System Preconditions
|
|
||||||
|
|
||||||
Preconditions before this project can be used:
|
|
||||||
|
|
||||||
+ up and running linux (virtual) machine
|
|
||||||
+ GIT client up and running
|
|
||||||
+ working copy of this git repository available
|
|
||||||
|
|
||||||
# Project use
|
|
||||||
|
|
||||||
To prepare your own working environment it is advised to follow the following steps:
|
|
||||||
|
|
||||||
+ open your virtual machine
|
|
||||||
+ start linux image
|
|
||||||
+ COPY this project directory to your own GIT archive. Think about the directory where you want put it and how you are going to name it.
|
|
||||||
+ start visual studio code and load the project
|
|
||||||
+ start a terminal in visual studio code
|
|
||||||
|
|
||||||
# Building the code
|
|
||||||
|
|
||||||
You build the code by using a terminal:
|
|
||||||
|
|
||||||
Action | Terminal command to type
|
|
||||||
---|---
|
|
||||||
Build main code: | make main
|
|
||||||
Build test code: | make main_test
|
|
||||||
Build all code: | make all
|
|
||||||
Run main code: | make run
|
|
||||||
Run test code: | make test
|
|
||||||
|
|
||||||
If you type make run and you get this message:
|
|
||||||
|
|
||||||
*failed, the implementation is empty.*
|
|
||||||
|
|
||||||
Then you have succesfully installed and ran the code.
|
|
||||||
If not, you have the fix whatever there needs to be fixed.
|
|
||||||
|
|
||||||
# Debugging
|
|
||||||
|
|
||||||
This project is configure to debug the test code.
|
|
||||||
Please refer to [https://code.visualstudio.com/docs/editor/debugging] on how to debug this code.
|
|
||||||
|
|
||||||
# Personal projects
|
|
||||||
|
|
||||||
If you have succesfully altered this project, commit & push it to your git archive.
|
|
||||||
|
|
||||||
Once this is done you have completed one complete development cycle and you can apply this knowledge in challenges to come.
|
|
||||||
@@ -1,278 +0,0 @@
|
|||||||
/* **********************************************
|
|
||||||
* generic linked list in plain c
|
|
||||||
* author: Freddy Hurkmans
|
|
||||||
* date: dec 20, 2014
|
|
||||||
* **********************************************/
|
|
||||||
|
|
||||||
/* ******************************************************************************
|
|
||||||
* This list is designed using object oriented ideas, but is implemented in c.
|
|
||||||
*
|
|
||||||
* The idea is: you construct a list for a certain data structure (say: mystruct):
|
|
||||||
* list_admin* mylist = construct_list(sizeof(mystruct))
|
|
||||||
* mylist contains private data for this list implementation. You need not worry
|
|
||||||
* about it, only give it as first parameter to each list method.
|
|
||||||
*
|
|
||||||
* This means you can have multiple lists at the same time, just make sure you
|
|
||||||
* give the right list_admin structure to the list function.
|
|
||||||
* When you're done with your list, just call the destructor: destruct_list(&mylist)
|
|
||||||
* The destructor automatically deletes remaining list elements and the list administration.
|
|
||||||
*
|
|
||||||
* As this list implementation keeps its own administration in list_admin, you need
|
|
||||||
* not worry about next pointers and such. Your structure doesn't even need pointers
|
|
||||||
* to itself, you only need to worry about data. A valid struct could thus be:
|
|
||||||
* typedef struct
|
|
||||||
* {
|
|
||||||
* int nr;
|
|
||||||
* char text[100];
|
|
||||||
* } mystruct;
|
|
||||||
*
|
|
||||||
* Adding data to the list is done using list_add_* methods, such as list_add_tail,
|
|
||||||
* which adds data to the end of the list:
|
|
||||||
* mystruct data = {10, "hello world!"};
|
|
||||||
* int result = list_add_tail(mylist, &data);
|
|
||||||
* You don't have to provide the size of your struct, you've already done that in
|
|
||||||
* the destructor. If result < 0 list_add_* has failed (either a parameter problem
|
|
||||||
* or malloc didn't give memory).
|
|
||||||
*
|
|
||||||
* You can get a pointer to your data using list_get_*, e.g. get the 2nd element:
|
|
||||||
* mystruct* dataptr = list_get_element(admin, 1);
|
|
||||||
* or get the last element:
|
|
||||||
* mystruct* dataptr = list_get_last(admin);
|
|
||||||
* If dataptr is not NULL it points to the correct data, else the operation failed.
|
|
||||||
*
|
|
||||||
* Searching for data in your list can be done with list_index_of*. list_index_of
|
|
||||||
* compares the data in each list item to the given data. If they are the same, it
|
|
||||||
* returns the index. If you want to search for an element with a certain value for
|
|
||||||
* nr or text (see mystruct) you can implement your own compare function and use
|
|
||||||
* list_index_of_special (check memcmp for required return values):
|
|
||||||
* int mycompare(void* p1, void* p2, size_t size)
|
|
||||||
* {
|
|
||||||
* // this example doesn't need size!
|
|
||||||
* mystruct* org = (mystruct*)p1;
|
|
||||||
* int* nr = (int*)p2;
|
|
||||||
* return org->nr - nr; // return 0 if they are the same
|
|
||||||
* }
|
|
||||||
* Say you want to search for an element that has nr 10:
|
|
||||||
* int nr = 10;
|
|
||||||
* int index = list_index_of_special(mylist, &nr, mycompare);
|
|
||||||
* As noted earlier: mycompare must have the same prototype as memcmp. In fact:
|
|
||||||
* list_index_of is a shortcut for list_index_of_special(mylist, data, memcmp).
|
|
||||||
*
|
|
||||||
* Finally you can delete items with list_delete_*. They should work rather
|
|
||||||
* straight forward. If they succeed they return 0. You don't have to delete
|
|
||||||
* all items before destructing your list.
|
|
||||||
*
|
|
||||||
* ******************************************************************************/
|
|
||||||
|
|
||||||
|
|
||||||
#include <string.h> /* for memcmp and memcpy */
|
|
||||||
|
|
||||||
#include "list.h"
|
|
||||||
|
|
||||||
static size_t data_size(const list_admin* admin);
|
|
||||||
static list_head* get_guaranteed_list_head_of_element_n(list_admin* admin, size_t index);
|
|
||||||
static list_head* get_list_head_of_element_n(list_admin* admin, size_t index);
|
|
||||||
static void remove_first_element(list_admin* admin);
|
|
||||||
static int remove_non_first_element(list_admin* admin, size_t index);
|
|
||||||
|
|
||||||
/* **********************************************
|
|
||||||
* Constructor / destructor
|
|
||||||
* **********************************************/
|
|
||||||
list_admin* construct_list(size_t element_size)
|
|
||||||
{
|
|
||||||
list_admin* admin = malloc(sizeof(*admin));
|
|
||||||
if (admin != NULL)
|
|
||||||
{
|
|
||||||
admin->head = NULL;
|
|
||||||
admin->element_size = element_size;
|
|
||||||
admin->nr_elements = 0;
|
|
||||||
}
|
|
||||||
return admin;
|
|
||||||
}
|
|
||||||
|
|
||||||
void destruct_list(list_admin** admin)
|
|
||||||
{
|
|
||||||
if ((admin != NULL) && (*admin != NULL))
|
|
||||||
{
|
|
||||||
while ((*admin)->head != NULL)
|
|
||||||
{
|
|
||||||
list_head* temp = (*admin)->head;
|
|
||||||
(*admin)->head = (*admin)->head->next;
|
|
||||||
free(temp);
|
|
||||||
temp = NULL;
|
|
||||||
}
|
|
||||||
free(*admin);
|
|
||||||
*admin = NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* **********************************************
|
|
||||||
* Public functions
|
|
||||||
* **********************************************/
|
|
||||||
int list_get_nr_elements(list_admin* admin)
|
|
||||||
{
|
|
||||||
int nr_elements = -1;
|
|
||||||
if (admin != NULL)
|
|
||||||
{
|
|
||||||
nr_elements = admin->nr_elements;
|
|
||||||
}
|
|
||||||
return nr_elements;
|
|
||||||
}
|
|
||||||
|
|
||||||
int list_add_tail(list_admin* admin, const void* data)
|
|
||||||
{
|
|
||||||
int result = -1;
|
|
||||||
if ((admin != NULL) && (data != NULL))
|
|
||||||
{
|
|
||||||
list_head* new = malloc(data_size(admin));
|
|
||||||
if (new != NULL)
|
|
||||||
{
|
|
||||||
result = 0;
|
|
||||||
new->next = NULL;
|
|
||||||
memcpy(new+1, data, admin->element_size);
|
|
||||||
|
|
||||||
if (admin->head == NULL)
|
|
||||||
{
|
|
||||||
admin->head = new;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
list_head* temp = get_guaranteed_list_head_of_element_n(admin, admin->nr_elements-1);
|
|
||||||
temp->next = new;
|
|
||||||
}
|
|
||||||
|
|
||||||
admin->nr_elements++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void* list_get_element(list_admin* admin, size_t index)
|
|
||||||
{
|
|
||||||
list_head* item = get_list_head_of_element_n(admin, index);
|
|
||||||
if(item != NULL)
|
|
||||||
{
|
|
||||||
item++; // user data is just beyond list_head, thus we must increase the pointer
|
|
||||||
}
|
|
||||||
return item;
|
|
||||||
}
|
|
||||||
|
|
||||||
void* list_get_last(list_admin* admin)
|
|
||||||
{
|
|
||||||
list_head* item = NULL;
|
|
||||||
if (admin != NULL)
|
|
||||||
{
|
|
||||||
item = list_get_element(admin, admin->nr_elements-1);
|
|
||||||
}
|
|
||||||
return item;
|
|
||||||
}
|
|
||||||
|
|
||||||
int list_index_of(list_admin* admin, const void* data)
|
|
||||||
{
|
|
||||||
return list_index_of_special(admin, data, memcmp);
|
|
||||||
}
|
|
||||||
|
|
||||||
int list_index_of_special(list_admin* admin, const void* data, CompareFuncPtr compare)
|
|
||||||
{
|
|
||||||
int index = -1;
|
|
||||||
if ((admin != NULL) && (data != NULL) && (compare != NULL))
|
|
||||||
{
|
|
||||||
list_head* temp = admin->head;
|
|
||||||
index = 0;
|
|
||||||
while ((temp != NULL) && (compare(temp+1, data, admin->element_size) != 0))
|
|
||||||
{
|
|
||||||
temp = temp->next;
|
|
||||||
index++;
|
|
||||||
}
|
|
||||||
if (temp == NULL)
|
|
||||||
{
|
|
||||||
index = -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return index;
|
|
||||||
}
|
|
||||||
|
|
||||||
int list_delete_item(list_admin* admin, size_t index)
|
|
||||||
{
|
|
||||||
int result = -1;
|
|
||||||
if ((admin != NULL) && (admin->head != NULL) && (index < admin->nr_elements))
|
|
||||||
{
|
|
||||||
if (index == 0)
|
|
||||||
{
|
|
||||||
result = 0;
|
|
||||||
remove_first_element(admin);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
result = remove_non_first_element(admin, index);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
int list_delete_last(list_admin* admin)
|
|
||||||
{
|
|
||||||
int result = -1;
|
|
||||||
if (admin != NULL)
|
|
||||||
{
|
|
||||||
result = list_delete_item(admin, admin->nr_elements - 1);
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* **********************************************
|
|
||||||
* Private functions
|
|
||||||
* **********************************************/
|
|
||||||
static size_t data_size(const list_admin* admin)
|
|
||||||
{
|
|
||||||
return admin->element_size + sizeof(list_head);
|
|
||||||
}
|
|
||||||
|
|
||||||
static list_head* get_guaranteed_list_head_of_element_n(list_admin* admin, size_t index)
|
|
||||||
{
|
|
||||||
list_head* item = admin->head;
|
|
||||||
for (size_t i = 0; (i < index) && (item != NULL); i++)
|
|
||||||
{
|
|
||||||
item = item->next;
|
|
||||||
}
|
|
||||||
return item;
|
|
||||||
}
|
|
||||||
|
|
||||||
static list_head* get_list_head_of_element_n(list_admin* admin, size_t index)
|
|
||||||
{
|
|
||||||
list_head* item = NULL;
|
|
||||||
if ((admin != NULL) && (index < admin->nr_elements))
|
|
||||||
{
|
|
||||||
item = get_guaranteed_list_head_of_element_n(admin, index);
|
|
||||||
}
|
|
||||||
return item;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void remove_first_element(list_admin* admin)
|
|
||||||
{
|
|
||||||
list_head* temp = admin->head;
|
|
||||||
admin->head = admin->head->next;
|
|
||||||
free(temp);
|
|
||||||
temp = NULL;
|
|
||||||
admin->nr_elements--;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int remove_non_first_element(list_admin* admin, size_t index)
|
|
||||||
{
|
|
||||||
int result = -1;
|
|
||||||
if (index > 0)
|
|
||||||
{
|
|
||||||
list_head* temp = get_list_head_of_element_n(admin, index-1);
|
|
||||||
if ((temp != NULL) && (temp->next != NULL)) // to remove element n, element n-1 and n must exist
|
|
||||||
{
|
|
||||||
result = 0;
|
|
||||||
list_head* to_delete = temp->next;
|
|
||||||
temp->next = to_delete->next;
|
|
||||||
free(to_delete);
|
|
||||||
to_delete = NULL;
|
|
||||||
admin->nr_elements--;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
@@ -1,52 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
typedef struct list_head
|
|
||||||
{
|
|
||||||
struct list_head* next;
|
|
||||||
} list_head;
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
struct list_head* head;
|
|
||||||
size_t element_size;
|
|
||||||
size_t nr_elements;
|
|
||||||
} list_admin;
|
|
||||||
|
|
||||||
typedef int (*CompareFuncPtr)(const void*, const void*, size_t);
|
|
||||||
|
|
||||||
// call the constructor before using the list:
|
|
||||||
// list_admin* mylist = construct_list(sizeof(mystruct));
|
|
||||||
// if mylist equals NULL, no memory could be allocated. Please don't
|
|
||||||
// mess with the admin data, this can corrupt your data.
|
|
||||||
list_admin* construct_list(size_t element_size);
|
|
||||||
|
|
||||||
// call the destructor when you're done, pass the list administration
|
|
||||||
// as referenced parameter (the variable will be set to NULL).
|
|
||||||
void destruct_list(list_admin** admin);
|
|
||||||
|
|
||||||
// Reads the number of elements in your list. Returns -1 in case of
|
|
||||||
// errors, else the number of elements.
|
|
||||||
int list_get_nr_elements(list_admin* admin);
|
|
||||||
|
|
||||||
// Add data to the end of the list. Returns -1 in case of errors, else 0
|
|
||||||
int list_add_tail(list_admin* admin, const void* data);
|
|
||||||
|
|
||||||
// Returns a pointer to the requested element. Returns NULL in case of
|
|
||||||
// errors (such as: the element does not exist).
|
|
||||||
void* list_get_element(list_admin* admin, size_t index);
|
|
||||||
void* list_get_last(list_admin* admin);
|
|
||||||
|
|
||||||
// Returns the index to the first found list element that's equal to data,
|
|
||||||
// or -1 in case of errors (such as: not found).
|
|
||||||
int list_index_of(list_admin* admin, const void* data);
|
|
||||||
|
|
||||||
// Returns the index to the first found list element for which cmp says it's,
|
|
||||||
// equal to data, or -1 in case of errors (such as: not found). cmp must behave
|
|
||||||
// just like memcmp, i.e.: return 0 when the data matches.
|
|
||||||
int list_index_of_special(list_admin* admin, const void* data, CompareFuncPtr cmp);
|
|
||||||
|
|
||||||
// Delete an item in the list. Returns -1 in case of errors, else 0.
|
|
||||||
int list_delete_item(list_admin* admin, size_t index);
|
|
||||||
int list_delete_last(list_admin* admin);
|
|
||||||
@@ -1,270 +0,0 @@
|
|||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <stdbool.h>
|
|
||||||
#include <time.h>
|
|
||||||
//#include <malloc.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "resource_detector.h"
|
|
||||||
|
|
||||||
#undef malloc
|
|
||||||
#undef free
|
|
||||||
#undef main
|
|
||||||
#undef fopen
|
|
||||||
#undef fclose
|
|
||||||
|
|
||||||
#include "list.h"
|
|
||||||
|
|
||||||
#define MAGIC_CODE 0x78563412
|
|
||||||
|
|
||||||
#define ADDR(addr,offset) ((addr) + (offset))
|
|
||||||
#define SET_MAGIC_CODE(addr,offset) *((int*) ADDR(addr,offset)) = MAGIC_CODE
|
|
||||||
#define MAGIC_CODE_OK(addr,offset) (*((int*) ADDR(addr,offset)) == MAGIC_CODE)
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
char* addr;
|
|
||||||
unsigned int size;
|
|
||||||
const char* file;
|
|
||||||
unsigned int line;
|
|
||||||
} mem_data;
|
|
||||||
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
FILE* addr;
|
|
||||||
const char* file_to_open;
|
|
||||||
const char* mode;
|
|
||||||
const char* file;
|
|
||||||
unsigned int line;
|
|
||||||
} file_data;
|
|
||||||
|
|
||||||
static list_admin* memlist = NULL;
|
|
||||||
static list_admin* filelist = NULL;
|
|
||||||
|
|
||||||
static int memory_compare(const void* meminfo, const void* address, size_t size)
|
|
||||||
{
|
|
||||||
mem_data* info = (mem_data*)meminfo;
|
|
||||||
char* addr = (char*)address;
|
|
||||||
return info->addr - addr;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int file_compare(const void* fileinfo, const void* address, size_t size)
|
|
||||||
{
|
|
||||||
file_data* info = (file_data*)fileinfo;
|
|
||||||
FILE* addr = (FILE*)address;
|
|
||||||
return info->addr - addr;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void
|
|
||||||
invalidate (mem_data* info)
|
|
||||||
{
|
|
||||||
char* user_addr;
|
|
||||||
char* raw_addr;
|
|
||||||
unsigned int size;
|
|
||||||
|
|
||||||
user_addr = info->addr;
|
|
||||||
size = info->size;
|
|
||||||
raw_addr = ADDR (user_addr, -sizeof(int));
|
|
||||||
|
|
||||||
if (!MAGIC_CODE_OK(user_addr, -sizeof(int)) || !MAGIC_CODE_OK(user_addr, size))
|
|
||||||
{
|
|
||||||
fprintf (stderr, "ERROR: addr %p (%s, line %d): out-of-bound access\n", (void*)user_addr, info->file, info->line);
|
|
||||||
}
|
|
||||||
|
|
||||||
memset (raw_addr, 0xff, size + (2 * sizeof(int)));
|
|
||||||
free (raw_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* replacement of malloc
|
|
||||||
*/
|
|
||||||
extern void*
|
|
||||||
xmalloc (unsigned int size, const char* file, unsigned int line)
|
|
||||||
{
|
|
||||||
char* raw_addr = malloc (size + (2 * sizeof(int)));
|
|
||||||
char* user_addr;
|
|
||||||
mem_data info = {NULL, 0, NULL, 0};
|
|
||||||
|
|
||||||
if (raw_addr == NULL)
|
|
||||||
{
|
|
||||||
fprintf (stderr, "ERROR: malloc failed for %d bytes (%s, line %d)\n", size, file, line);
|
|
||||||
return (NULL);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
user_addr = ADDR (raw_addr, sizeof (int));
|
|
||||||
SET_MAGIC_CODE (raw_addr, 0);
|
|
||||||
SET_MAGIC_CODE (user_addr, size);
|
|
||||||
|
|
||||||
info.addr = user_addr;
|
|
||||||
info.size = size;
|
|
||||||
info.file = file;
|
|
||||||
info.line = line;
|
|
||||||
list_add_tail(memlist, &info);
|
|
||||||
}
|
|
||||||
return ((void*) user_addr);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* replacement of free
|
|
||||||
*/
|
|
||||||
extern void
|
|
||||||
xfree (void* addr, const char* filename, int linenr)
|
|
||||||
{
|
|
||||||
char* user_addr = (char*) addr;
|
|
||||||
mem_data* info = NULL;
|
|
||||||
|
|
||||||
/* check if allocated memory is in our list and retrieve its info */
|
|
||||||
int index = list_index_of_special(memlist, addr, memory_compare);
|
|
||||||
info = list_get_element(memlist, index);
|
|
||||||
|
|
||||||
if (info == NULL)
|
|
||||||
{
|
|
||||||
fprintf (stderr, "ERROR: trying to free memory that was not malloc-ed (addr %p) in %s : %d\n", (void*)user_addr, filename, linenr);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
invalidate (info);
|
|
||||||
list_delete_item(memlist, index);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
print_empty_lines(int n)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
for (i = 0; i < n; i++)
|
|
||||||
{
|
|
||||||
fprintf(stderr, "\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void set_colour_red(void)
|
|
||||||
{
|
|
||||||
fprintf(stderr, "\033[10;31m");
|
|
||||||
}
|
|
||||||
static void set_colour_gray(void)
|
|
||||||
{
|
|
||||||
fprintf(stderr, "\033[22;37m");
|
|
||||||
}
|
|
||||||
static void
|
|
||||||
print_line(void)
|
|
||||||
{
|
|
||||||
fprintf (stderr, "---------------------------------------------------------\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
print_not_good(void)
|
|
||||||
{
|
|
||||||
set_colour_gray();
|
|
||||||
print_line();
|
|
||||||
set_colour_red();
|
|
||||||
fprintf (stderr, " # # ###\n");
|
|
||||||
fprintf (stderr, " ## # #### ##### #### #### #### ##### ###\n");
|
|
||||||
fprintf (stderr, " # # # # # # # # # # # # # # ###\n");
|
|
||||||
fprintf (stderr, " # # # # # # # # # # # # # # \n");
|
|
||||||
fprintf (stderr, " # # # # # # # ### # # # # # # \n");
|
|
||||||
fprintf (stderr, " # ## # # # # # # # # # # # ###\n");
|
|
||||||
fprintf (stderr, " # # #### # #### #### #### ##### ###\n");
|
|
||||||
set_colour_gray();
|
|
||||||
print_line();
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* writes all info of the unallocated memory
|
|
||||||
*/
|
|
||||||
static void
|
|
||||||
resource_detection (void)
|
|
||||||
{
|
|
||||||
time_t now = time (NULL);
|
|
||||||
|
|
||||||
int forgotten_frees = list_get_nr_elements(memlist);
|
|
||||||
int nr_files_open = list_get_nr_elements(filelist);
|
|
||||||
|
|
||||||
if ((forgotten_frees > 0) || (nr_files_open > 0))
|
|
||||||
{
|
|
||||||
print_empty_lines(15);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (forgotten_frees > 0)
|
|
||||||
{
|
|
||||||
mem_data* info = NULL;
|
|
||||||
print_line();
|
|
||||||
fprintf (stderr, "Memory Leak Summary, generated: %s", ctime (&now));
|
|
||||||
print_not_good();
|
|
||||||
set_colour_red();
|
|
||||||
while((info = list_get_element(memlist, 0)) != NULL)
|
|
||||||
{
|
|
||||||
fprintf (stderr, "forgot to free address: %p (%d bytes) that was allocated in: %s on line: %d\n",
|
|
||||||
(void*)info->addr, info->size, info->file, info->line);
|
|
||||||
list_delete_item(memlist, 0);
|
|
||||||
}
|
|
||||||
set_colour_gray();
|
|
||||||
print_line();
|
|
||||||
print_empty_lines(1);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (nr_files_open > 0)
|
|
||||||
{
|
|
||||||
file_data* info = NULL;
|
|
||||||
print_line();
|
|
||||||
fprintf (stderr, "File Management Summary, generated: %s", ctime (&now));
|
|
||||||
print_not_good();
|
|
||||||
set_colour_red();
|
|
||||||
while((info = list_get_element(filelist, 0)) != NULL)
|
|
||||||
{
|
|
||||||
fprintf (stderr, "forgot to close file: %s (ptr %p, mode \"%s\") that was opened from: %s on line: %d\n",
|
|
||||||
info->file_to_open, (void*)(info->addr), info->mode, info->file, info->line);
|
|
||||||
list_delete_item(filelist, 0);
|
|
||||||
}
|
|
||||||
set_colour_gray();
|
|
||||||
print_line();
|
|
||||||
print_empty_lines(1);
|
|
||||||
}
|
|
||||||
if ((forgotten_frees == 0) && (nr_files_open == 0))
|
|
||||||
{
|
|
||||||
printf ("\nResource checks: OK\n\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
destruct_list(&memlist);
|
|
||||||
destruct_list(&filelist);
|
|
||||||
}
|
|
||||||
|
|
||||||
extern FILE*
|
|
||||||
xfopen (const char* file_to_open, const char* mode, const char* filename, int linenr)
|
|
||||||
{
|
|
||||||
file_data info = {0};
|
|
||||||
info.addr = fopen(file_to_open, mode);
|
|
||||||
if (info.addr != NULL)
|
|
||||||
{
|
|
||||||
info.file_to_open = file_to_open;
|
|
||||||
info.mode = mode;
|
|
||||||
info.file = filename;
|
|
||||||
info.line = linenr;
|
|
||||||
list_add_tail(filelist, &info);
|
|
||||||
}
|
|
||||||
return info.addr;
|
|
||||||
}
|
|
||||||
|
|
||||||
extern int
|
|
||||||
xfclose(FILE* fptr, const char* filename, int linenr)
|
|
||||||
{
|
|
||||||
int index = list_index_of_special(filelist, fptr, file_compare);
|
|
||||||
if (index < 0)
|
|
||||||
{
|
|
||||||
fprintf (stderr, "ERROR: trying to close an unopened file in %s on line number %d.\n", filename, linenr);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
list_delete_item(filelist, index);
|
|
||||||
return (fclose (fptr));
|
|
||||||
}
|
|
||||||
|
|
||||||
extern int
|
|
||||||
main (int argc, char* argv[])
|
|
||||||
{
|
|
||||||
atexit (resource_detection);
|
|
||||||
memlist = construct_list(sizeof(mem_data));
|
|
||||||
filelist = construct_list(sizeof(file_data));
|
|
||||||
|
|
||||||
return (xmain (argc, argv));
|
|
||||||
}
|
|
||||||
@@ -1,18 +0,0 @@
|
|||||||
#ifndef RESOURCE_DETECTOR_H
|
|
||||||
#define RESOURCE_DETECTOR_H
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
#define main xmain
|
|
||||||
#define malloc(size) xmalloc ((size), (__FILE__), (__LINE__))
|
|
||||||
#define free(addr) xfree ((addr), __FILE__, __LINE__)
|
|
||||||
#define fopen(name,mode) xfopen ((name),(mode), __FILE__, __LINE__)
|
|
||||||
#define fclose(fptr) xfclose ((fptr), __FILE__, __LINE__)
|
|
||||||
|
|
||||||
extern int xmain(int argc, char* argv[]);
|
|
||||||
extern void* xmalloc(unsigned int size, const char* file, unsigned int line);
|
|
||||||
extern void xfree(void* addr, const char* filename, int linenr);
|
|
||||||
extern FILE* xfopen(const char* file_to_open, const char* mode, const char* filename, int linenr);
|
|
||||||
extern int xfclose(FILE* fptr, const char* filename, int linenr);
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,28 +0,0 @@
|
|||||||
UNITY_FOLDER=../Unity
|
|
||||||
TEST_INC_DIRS=$(INC_DIRS) -I$(UNITY_FOLDER)
|
|
||||||
|
|
||||||
TEST_FILES=$(UNITY_FOLDER)/unity.c \
|
|
||||||
list_test.c \
|
|
||||||
list.c
|
|
||||||
|
|
||||||
HEADER_FILES=*.h
|
|
||||||
|
|
||||||
TEST = list_test
|
|
||||||
|
|
||||||
CC=gcc
|
|
||||||
|
|
||||||
SYMBOLS=-Wall -Werror -pedantic -O0 -ggdb -std=c99
|
|
||||||
TEST_SYMBOLS=$(SYMBOLS) -DTEST
|
|
||||||
|
|
||||||
.PHONY: clean test
|
|
||||||
|
|
||||||
all: $(TEST)
|
|
||||||
|
|
||||||
$(TEST): Makefile $(TEST_FILES) $(HEADER_FILES)
|
|
||||||
$(CC) $(TEST_INC_DIRS) $(TEST_SYMBOLS) $(TEST_FILES) -o $(TEST)
|
|
||||||
|
|
||||||
clean:
|
|
||||||
rm -f list $(TEST)
|
|
||||||
|
|
||||||
test: $(TEST)
|
|
||||||
@valgrind ./$(TEST)
|
|
||||||
@@ -1,300 +0,0 @@
|
|||||||
#include <string.h> /* for memcmp */
|
|
||||||
|
|
||||||
#include "list.h"
|
|
||||||
#include "unity.h"
|
|
||||||
|
|
||||||
// I rather dislike keeping line numbers updated, so I made my own macro to ditch the line number
|
|
||||||
#define MY_RUN_TEST(func) RUN_TEST(func, 0)
|
|
||||||
|
|
||||||
static list_admin* mylist = NULL;
|
|
||||||
typedef struct
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
int j;
|
|
||||||
} test_struct;
|
|
||||||
|
|
||||||
// compare function that returns 0 if test_struct.i matches, it ignores .j
|
|
||||||
static int compare_test_func(const void* p1, const void* p2, size_t size)
|
|
||||||
{
|
|
||||||
size = size; // to prevent warnings
|
|
||||||
const test_struct* data1 = (const test_struct*)p1;
|
|
||||||
const test_struct* data2 = (const test_struct*)p2;
|
|
||||||
return data1->i - data2->i;
|
|
||||||
}
|
|
||||||
// check n items in list against verify_data
|
|
||||||
// IMPORTANT: this function must check using list_get_element,
|
|
||||||
// else the test for that function is no longer useful
|
|
||||||
static void check_n_list_elements_ok(list_admin* admin, int nr_items, const test_struct* verify_data)
|
|
||||||
{
|
|
||||||
for(int i = 0; i < nr_items; i++)
|
|
||||||
{
|
|
||||||
test_struct* ptr = list_get_element(admin, i);
|
|
||||||
TEST_ASSERT_NOT_NULL(ptr);
|
|
||||||
TEST_ASSERT_EQUAL(0, memcmp(verify_data+i, ptr, sizeof(*ptr)));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void setUp(void)
|
|
||||||
{
|
|
||||||
// This is run before EACH test
|
|
||||||
mylist = construct_list(sizeof(test_struct));
|
|
||||||
TEST_ASSERT_NOT_NULL(mylist);
|
|
||||||
}
|
|
||||||
|
|
||||||
void tearDown(void)
|
|
||||||
{
|
|
||||||
// This is run after EACH test
|
|
||||||
destruct_list(&mylist);
|
|
||||||
TEST_ASSERT_NULL(mylist);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_ConstructList(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_NULL(mylist->head);
|
|
||||||
TEST_ASSERT_EQUAL(sizeof(test_struct), mylist->element_size);
|
|
||||||
TEST_ASSERT_EQUAL(0, mylist->nr_elements);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_NrElements_parameters(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_get_nr_elements(NULL));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_AddData_parameters(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_add_tail(mylist, NULL));
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_add_tail(NULL, mylist));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_AddData(void)
|
|
||||||
{
|
|
||||||
test_struct data = {3, 4};
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &data));
|
|
||||||
|
|
||||||
TEST_ASSERT_NOT_NULL(mylist->head);
|
|
||||||
TEST_ASSERT_EQUAL(1, list_get_nr_elements(mylist));
|
|
||||||
list_head* head = mylist->head;
|
|
||||||
test_struct* element = (test_struct*)(head+1);
|
|
||||||
TEST_ASSERT_EQUAL(data.i, element->i);
|
|
||||||
TEST_ASSERT_EQUAL(data.j, element->j);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_Add2PiecesOfData(void)
|
|
||||||
{
|
|
||||||
test_struct data1 = {8, 9};
|
|
||||||
test_struct data2 = {-3, -4};
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &data1));
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &data2));
|
|
||||||
|
|
||||||
TEST_ASSERT_NOT_NULL(mylist->head);
|
|
||||||
TEST_ASSERT_NOT_NULL(mylist->head->next);
|
|
||||||
TEST_ASSERT_EQUAL(2, list_get_nr_elements(mylist));
|
|
||||||
list_head* head = mylist->head->next;
|
|
||||||
test_struct* element = (test_struct*)(head+1);
|
|
||||||
TEST_ASSERT_EQUAL(data2.i, element->i);
|
|
||||||
TEST_ASSERT_EQUAL(data2.j, element->j);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_GetElement_parameters(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_NULL(list_get_element(NULL, 0));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_GetElement(void)
|
|
||||||
{
|
|
||||||
const test_struct data[] = {{8, 9}, {-3, -4}, {21, 56}, {0, 0}};
|
|
||||||
const int nr_elements = sizeof(data)/sizeof(data[0]);
|
|
||||||
|
|
||||||
for(int i = 0; i < nr_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &(data[i])));
|
|
||||||
}
|
|
||||||
|
|
||||||
check_n_list_elements_ok(mylist, nr_elements, data); // checks using list_get_element
|
|
||||||
|
|
||||||
TEST_ASSERT_NULL(list_get_element(mylist, nr_elements));
|
|
||||||
TEST_ASSERT_NULL(list_get_element(mylist, -1));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_GetLast_parameters(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_NULL(list_get_last(NULL));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_GetLast(void)
|
|
||||||
{
|
|
||||||
const test_struct data[] = {{8, 9}, {-3, -4}, {21, 56}, {0, 0}};
|
|
||||||
const int nr_elements = sizeof(data)/sizeof(data[0]);
|
|
||||||
|
|
||||||
TEST_ASSERT_NULL(list_get_last(mylist));
|
|
||||||
for(int i = 0; i < nr_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &(data[i])));
|
|
||||||
test_struct* ptr = list_get_last(mylist);
|
|
||||||
TEST_ASSERT_NOT_NULL(ptr);
|
|
||||||
TEST_ASSERT_EQUAL(0, memcmp(&(data[i]), ptr, sizeof(*ptr)));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_IndexOf_parameters(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_index_of(mylist, NULL));
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_index_of(NULL, mylist));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_IndexOf(void)
|
|
||||||
{
|
|
||||||
const test_struct real_data[] = {{8, 9}, {-3, -4}, {21, 56}};
|
|
||||||
const int nr_real_elements = sizeof(real_data)/sizeof(real_data[0]);
|
|
||||||
const test_struct false_data[] = {{-3, 9}, {8, 56}, {21, -4}, {0, 0}};
|
|
||||||
const int nr_false_elements = sizeof(false_data)/sizeof(false_data[0]);
|
|
||||||
for(int i = 0; i < nr_real_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &(real_data[i])));
|
|
||||||
}
|
|
||||||
|
|
||||||
for(int i = 0; i < nr_real_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(i, list_index_of(mylist, &(real_data[i])));
|
|
||||||
}
|
|
||||||
for(int i = 0; i < nr_false_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_index_of(mylist, &(false_data[i])));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_IndexOfSpecial_parameters(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_index_of_special(mylist, NULL, compare_test_func));
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_index_of_special(NULL, mylist, compare_test_func));
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_index_of_special(mylist, mylist, NULL));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_IndexOfSpecial(void)
|
|
||||||
{
|
|
||||||
const test_struct data[] = {{8, 9}, {-3, -4}, {21, 56}}; // data in list
|
|
||||||
const test_struct real_data[] = {{8, -4}, {-3, 56}, {21, 9}}; // data to search for (i equals)
|
|
||||||
const int nr_real_elements = sizeof(real_data)/sizeof(real_data[0]);
|
|
||||||
const test_struct false_data[] = {{-2, 9}, {9, -4}, {22, 56}, {0, 0}}; // data that doesn't exist
|
|
||||||
const int nr_false_elements = sizeof(false_data)/sizeof(false_data[0]);
|
|
||||||
|
|
||||||
// first make sure our compare function works
|
|
||||||
for(int i = 0; i < nr_real_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(0, compare_test_func(&(data[i]), &(real_data[i]), 0));
|
|
||||||
for (int j = 0; j < nr_false_elements; j++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_NOT_EQUAL(0, compare_test_func(&(data[i]), &(false_data[j]), 0))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for(int i = 0; i < nr_real_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &(data[i])));
|
|
||||||
}
|
|
||||||
|
|
||||||
for(int i = 0; i < nr_real_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(i, list_index_of_special(mylist, &(real_data[i]), compare_test_func));
|
|
||||||
}
|
|
||||||
for(int i = 0; i < nr_false_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_index_of_special(mylist, &(false_data[i]), compare_test_func));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_DeleteItem_parameters(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_delete_item(NULL, 0));
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_delete_item(mylist, -1));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_DeleteItem(void)
|
|
||||||
{
|
|
||||||
const test_struct data[] = {{8, 9}, {-3, -4}, {21, 56}, {0, 0}, {12, 12345}};
|
|
||||||
int nr_elements = sizeof(data)/sizeof(data[0]);
|
|
||||||
const test_struct data_noFirst[] = {{-3, -4}, {21, 56}, {0, 0}, {12, 12345}};
|
|
||||||
const test_struct data_noLast[] = {{-3, -4}, {21, 56}, {0, 0}};
|
|
||||||
const test_struct data_noMiddle[] = {{-3, -4}, {0, 0}};
|
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_delete_item(mylist, 0));
|
|
||||||
for(int i = 0; i < nr_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &(data[i])));
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL(0, list_delete_item(mylist, 0));
|
|
||||||
nr_elements--;
|
|
||||||
TEST_ASSERT_EQUAL(nr_elements, list_get_nr_elements(mylist));
|
|
||||||
|
|
||||||
check_n_list_elements_ok(mylist, nr_elements, data_noFirst);
|
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL(0, list_delete_item(mylist, nr_elements-1));
|
|
||||||
nr_elements--;
|
|
||||||
TEST_ASSERT_EQUAL(nr_elements, list_get_nr_elements(mylist));
|
|
||||||
|
|
||||||
check_n_list_elements_ok(mylist, nr_elements, data_noLast);
|
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL(0, list_delete_item(mylist, 1));
|
|
||||||
nr_elements--;
|
|
||||||
TEST_ASSERT_EQUAL(nr_elements, list_get_nr_elements(mylist));
|
|
||||||
|
|
||||||
check_n_list_elements_ok(mylist, nr_elements, data_noMiddle);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_DeleteLast_parameters(void)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_delete_last(NULL));
|
|
||||||
}
|
|
||||||
|
|
||||||
static void test_DeleteLast(void)
|
|
||||||
{
|
|
||||||
const test_struct data[] = {{8, 9}, {-3, -4}, {21, 56}, {0, 0}, {12, 12345}};
|
|
||||||
int nr_elements = sizeof(data)/sizeof(data[0]);
|
|
||||||
|
|
||||||
TEST_ASSERT_EQUAL(-1, list_delete_last(mylist));
|
|
||||||
for(int i = 0; i < nr_elements; i++)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(0, list_add_tail(mylist, &(data[i])));
|
|
||||||
}
|
|
||||||
|
|
||||||
for (int i = nr_elements-1; i >= 0; i--)
|
|
||||||
{
|
|
||||||
TEST_ASSERT_EQUAL(0, list_delete_last(mylist));
|
|
||||||
TEST_ASSERT_EQUAL(i, list_get_nr_elements(mylist));
|
|
||||||
check_n_list_elements_ok(mylist, i, data);
|
|
||||||
}
|
|
||||||
|
|
||||||
TEST_ASSERT_NULL(mylist->head);
|
|
||||||
TEST_ASSERT_EQUAL(0, list_get_nr_elements(mylist));
|
|
||||||
}
|
|
||||||
|
|
||||||
int main(void)
|
|
||||||
{
|
|
||||||
UnityBegin();
|
|
||||||
|
|
||||||
MY_RUN_TEST(test_ConstructList);
|
|
||||||
MY_RUN_TEST(test_NrElements_parameters);
|
|
||||||
MY_RUN_TEST(test_AddData_parameters);
|
|
||||||
MY_RUN_TEST(test_AddData);
|
|
||||||
MY_RUN_TEST(test_Add2PiecesOfData);
|
|
||||||
MY_RUN_TEST(test_GetElement_parameters);
|
|
||||||
MY_RUN_TEST(test_GetElement);
|
|
||||||
MY_RUN_TEST(test_GetLast_parameters);
|
|
||||||
MY_RUN_TEST(test_GetLast);
|
|
||||||
MY_RUN_TEST(test_IndexOf_parameters);
|
|
||||||
MY_RUN_TEST(test_IndexOf);
|
|
||||||
MY_RUN_TEST(test_IndexOfSpecial_parameters);
|
|
||||||
MY_RUN_TEST(test_IndexOfSpecial);
|
|
||||||
MY_RUN_TEST(test_DeleteItem_parameters);
|
|
||||||
MY_RUN_TEST(test_DeleteItem);
|
|
||||||
MY_RUN_TEST(test_DeleteLast_parameters);
|
|
||||||
MY_RUN_TEST(test_DeleteLast);
|
|
||||||
// MY_RUN_TEST();
|
|
||||||
// MY_RUN_TEST();
|
|
||||||
// MY_RUN_TEST();
|
|
||||||
// MY_RUN_TEST();
|
|
||||||
|
|
||||||
return UnityEnd();
|
|
||||||
}
|
|
||||||
@@ -1,841 +0,0 @@
|
|||||||
/* ==========================================
|
|
||||||
Unity Project - A Test Framework for C
|
|
||||||
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
|
||||||
[Released under MIT License. Please refer to license.txt for details]
|
|
||||||
========================================== */
|
|
||||||
|
|
||||||
#include "unity.h"
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#define UNITY_FAIL_AND_BAIL { Unity.CurrentTestFailed = 1; UNITY_OUTPUT_CHAR('\n'); longjmp(Unity.AbortFrame, 1); }
|
|
||||||
#define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_CHAR('\n'); longjmp(Unity.AbortFrame, 1); }
|
|
||||||
/// return prematurely if we are already in failure or ignore state
|
|
||||||
#define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} }
|
|
||||||
#define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\n'); }
|
|
||||||
|
|
||||||
struct _Unity Unity = { 0 };
|
|
||||||
|
|
||||||
const char* UnityStrNull = "NULL";
|
|
||||||
const char* UnityStrSpacer = ". ";
|
|
||||||
const char* UnityStrExpected = " Expected ";
|
|
||||||
const char* UnityStrWas = " Was ";
|
|
||||||
const char* UnityStrTo = " To ";
|
|
||||||
const char* UnityStrElement = " Element ";
|
|
||||||
const char* UnityStrMemory = " Memory Mismatch";
|
|
||||||
const char* UnityStrDelta = " Values Not Within Delta ";
|
|
||||||
const char* UnityStrPointless= " You Asked Me To Compare Nothing, Which Was Pointless.";
|
|
||||||
const char* UnityStrNullPointerForExpected= " Expected pointer to be NULL";
|
|
||||||
const char* UnityStrNullPointerForActual = " Actual pointer was NULL";
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
// Pretty Printers & Test Result Output Handlers
|
|
||||||
//-----------------------------------------------
|
|
||||||
|
|
||||||
void UnityPrint(const char* string)
|
|
||||||
{
|
|
||||||
const char* pch = string;
|
|
||||||
|
|
||||||
if (pch != NULL)
|
|
||||||
{
|
|
||||||
while (*pch)
|
|
||||||
{
|
|
||||||
// printable characters plus CR & LF are printed
|
|
||||||
if ((*pch <= 126) && (*pch >= 32))
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR(*pch);
|
|
||||||
}
|
|
||||||
//write escaped carriage returns
|
|
||||||
else if (*pch == 13)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('\\');
|
|
||||||
UNITY_OUTPUT_CHAR('r');
|
|
||||||
}
|
|
||||||
//write escaped line feeds
|
|
||||||
else if (*pch == 10)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('\\');
|
|
||||||
UNITY_OUTPUT_CHAR('n');
|
|
||||||
}
|
|
||||||
// unprintable characters are shown as codes
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('\\');
|
|
||||||
UnityPrintNumberHex((_U_SINT)*pch, 2);
|
|
||||||
}
|
|
||||||
pch++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style)
|
|
||||||
{
|
|
||||||
if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
|
|
||||||
{
|
|
||||||
UnityPrintNumber(number);
|
|
||||||
}
|
|
||||||
else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
|
|
||||||
{
|
|
||||||
UnityPrintNumberUnsigned((_U_UINT)number);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UnityPrintNumberHex((_U_UINT)number, (style & 0x000F) << 1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
/// basically do an itoa using as little ram as possible
|
|
||||||
void UnityPrintNumber(const _U_SINT number_to_print)
|
|
||||||
{
|
|
||||||
_U_SINT divisor = 1;
|
|
||||||
_U_SINT next_divisor;
|
|
||||||
_U_SINT number = number_to_print;
|
|
||||||
|
|
||||||
if (number < 0)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('-');
|
|
||||||
number = -number;
|
|
||||||
}
|
|
||||||
|
|
||||||
// figure out initial divisor
|
|
||||||
while (number / divisor > 9)
|
|
||||||
{
|
|
||||||
next_divisor = divisor * 10;
|
|
||||||
if (next_divisor > divisor)
|
|
||||||
divisor = next_divisor;
|
|
||||||
else
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
// now mod and print, then divide divisor
|
|
||||||
do
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
|
|
||||||
divisor /= 10;
|
|
||||||
}
|
|
||||||
while (divisor > 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
/// basically do an itoa using as little ram as possible
|
|
||||||
void UnityPrintNumberUnsigned(const _U_UINT number)
|
|
||||||
{
|
|
||||||
_U_UINT divisor = 1;
|
|
||||||
_U_UINT next_divisor;
|
|
||||||
|
|
||||||
// figure out initial divisor
|
|
||||||
while (number / divisor > 9)
|
|
||||||
{
|
|
||||||
next_divisor = divisor * 10;
|
|
||||||
if (next_divisor > divisor)
|
|
||||||
divisor = next_divisor;
|
|
||||||
else
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
// now mod and print, then divide divisor
|
|
||||||
do
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
|
|
||||||
divisor /= 10;
|
|
||||||
}
|
|
||||||
while (divisor > 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print)
|
|
||||||
{
|
|
||||||
_U_UINT nibble;
|
|
||||||
char nibbles = nibbles_to_print;
|
|
||||||
UNITY_OUTPUT_CHAR('0');
|
|
||||||
UNITY_OUTPUT_CHAR('x');
|
|
||||||
|
|
||||||
while (nibbles > 0)
|
|
||||||
{
|
|
||||||
nibble = (number >> (--nibbles << 2)) & 0x0000000F;
|
|
||||||
if (nibble <= 9)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR((char)('0' + nibble));
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
|
|
||||||
{
|
|
||||||
_U_UINT current_bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1);
|
|
||||||
_US32 i;
|
|
||||||
|
|
||||||
for (i = 0; i < UNITY_INT_WIDTH; i++)
|
|
||||||
{
|
|
||||||
if (current_bit & mask)
|
|
||||||
{
|
|
||||||
if (current_bit & number)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('1');
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('0');
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('X');
|
|
||||||
}
|
|
||||||
current_bit = current_bit >> 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
#ifdef UNITY_FLOAT_VERBOSE
|
|
||||||
void UnityPrintFloat(_UF number)
|
|
||||||
{
|
|
||||||
char TempBuffer[32];
|
|
||||||
sprintf(TempBuffer, "%.6f", number);
|
|
||||||
UnityPrint(TempBuffer);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
|
|
||||||
{
|
|
||||||
UnityPrint(file);
|
|
||||||
UNITY_OUTPUT_CHAR(':');
|
|
||||||
UnityPrintNumber(line);
|
|
||||||
UNITY_OUTPUT_CHAR(':');
|
|
||||||
UnityPrint(Unity.CurrentTestName);
|
|
||||||
UNITY_OUTPUT_CHAR(':');
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line)
|
|
||||||
{
|
|
||||||
UnityTestResultsBegin(Unity.TestFile, line);
|
|
||||||
UnityPrint("FAIL:");
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityConcludeTest(void)
|
|
||||||
{
|
|
||||||
if (Unity.CurrentTestIgnored)
|
|
||||||
{
|
|
||||||
Unity.TestIgnores++;
|
|
||||||
}
|
|
||||||
else if (!Unity.CurrentTestFailed)
|
|
||||||
{
|
|
||||||
UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
|
|
||||||
UnityPrint("PASS");
|
|
||||||
UNITY_PRINT_EOL;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
Unity.TestFailures++;
|
|
||||||
}
|
|
||||||
|
|
||||||
Unity.CurrentTestFailed = 0;
|
|
||||||
Unity.CurrentTestIgnored = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityAddMsgIfSpecified(const char* msg)
|
|
||||||
{
|
|
||||||
if (msg)
|
|
||||||
{
|
|
||||||
UnityPrint(UnityStrSpacer);
|
|
||||||
UnityPrint(msg);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
|
|
||||||
{
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
if (expected != NULL)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('\'');
|
|
||||||
UnityPrint(expected);
|
|
||||||
UNITY_OUTPUT_CHAR('\'');
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UnityPrint(UnityStrNull);
|
|
||||||
}
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
if (actual != NULL)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR('\'');
|
|
||||||
UnityPrint(actual);
|
|
||||||
UNITY_OUTPUT_CHAR('\'');
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UnityPrint(UnityStrNull);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
// Assertion & Control Helpers
|
|
||||||
//-----------------------------------------------
|
|
||||||
|
|
||||||
int UnityCheckArraysForNull(const void* expected, const void* actual, const UNITY_LINE_TYPE lineNumber, const char* msg)
|
|
||||||
{
|
|
||||||
//return true if they are both NULL
|
|
||||||
if ((expected == NULL) && (actual == NULL))
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
//throw error if just expected is NULL
|
|
||||||
if (expected == NULL)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrNullPointerForExpected);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
|
|
||||||
//throw error if just actual is NULL
|
|
||||||
if (actual == NULL)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrNullPointerForActual);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
|
|
||||||
//return false if neither is NULL
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
// Assertion Functions
|
|
||||||
//-----------------------------------------------
|
|
||||||
|
|
||||||
void UnityAssertBits(const _U_SINT mask,
|
|
||||||
const _U_SINT expected,
|
|
||||||
const _U_SINT actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber)
|
|
||||||
{
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
if ((mask & expected) != (mask & actual))
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintMask(mask, expected);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintMask(mask, actual);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityAssertEqualNumber(const _U_SINT expected,
|
|
||||||
const _U_SINT actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber,
|
|
||||||
const UNITY_DISPLAY_STYLE_T style)
|
|
||||||
{
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
if (expected != actual)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintNumberByStyle(expected, style);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintNumberByStyle(actual, style);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityAssertEqualIntArray(const _U_SINT* expected,
|
|
||||||
const _U_SINT* actual,
|
|
||||||
const _UU32 num_elements,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber,
|
|
||||||
const UNITY_DISPLAY_STYLE_T style)
|
|
||||||
{
|
|
||||||
_UU32 elements = num_elements;
|
|
||||||
const _US8* ptr_exp = (_US8*)expected;
|
|
||||||
const _US8* ptr_act = (_US8*)actual;
|
|
||||||
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
if (elements == 0)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrPointless);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
|
|
||||||
return;
|
|
||||||
|
|
||||||
switch(style)
|
|
||||||
{
|
|
||||||
case UNITY_DISPLAY_STYLE_HEX8:
|
|
||||||
case UNITY_DISPLAY_STYLE_INT8:
|
|
||||||
case UNITY_DISPLAY_STYLE_UINT8:
|
|
||||||
while (elements--)
|
|
||||||
{
|
|
||||||
if (*ptr_exp != *ptr_act)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrElement);
|
|
||||||
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintNumberByStyle(*ptr_exp, style);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintNumberByStyle(*ptr_act, style);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
ptr_exp += 1;
|
|
||||||
ptr_act += 1;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case UNITY_DISPLAY_STYLE_HEX16:
|
|
||||||
case UNITY_DISPLAY_STYLE_INT16:
|
|
||||||
case UNITY_DISPLAY_STYLE_UINT16:
|
|
||||||
while (elements--)
|
|
||||||
{
|
|
||||||
if (*(_US16*)ptr_exp != *(_US16*)ptr_act)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrElement);
|
|
||||||
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintNumberByStyle(*(_US16*)ptr_exp, style);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintNumberByStyle(*(_US16*)ptr_act, style);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
ptr_exp += 2;
|
|
||||||
ptr_act += 2;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
#ifdef UNITY_SUPPORT_64
|
|
||||||
case UNITY_DISPLAY_STYLE_HEX64:
|
|
||||||
case UNITY_DISPLAY_STYLE_INT64:
|
|
||||||
case UNITY_DISPLAY_STYLE_UINT64:
|
|
||||||
while (elements--)
|
|
||||||
{
|
|
||||||
if (*(_US64*)ptr_exp != *(_US64*)ptr_act)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrElement);
|
|
||||||
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintNumberByStyle(*(_US64*)ptr_exp, style);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintNumberByStyle(*(_US64*)ptr_act, style);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
ptr_exp += 8;
|
|
||||||
ptr_act += 8;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
#endif
|
|
||||||
default:
|
|
||||||
while (elements--)
|
|
||||||
{
|
|
||||||
if (*(_US32*)ptr_exp != *(_US32*)ptr_act)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrElement);
|
|
||||||
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintNumberByStyle(*(_US32*)ptr_exp, style);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintNumberByStyle(*(_US32*)ptr_act, style);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
ptr_exp += 4;
|
|
||||||
ptr_act += 4;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
#ifndef UNITY_EXCLUDE_FLOAT
|
|
||||||
void UnityAssertEqualFloatArray(const _UF* expected,
|
|
||||||
const _UF* actual,
|
|
||||||
const _UU32 num_elements,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber)
|
|
||||||
{
|
|
||||||
_UU32 elements = num_elements;
|
|
||||||
const _UF* ptr_expected = expected;
|
|
||||||
const _UF* ptr_actual = actual;
|
|
||||||
_UF diff, tol;
|
|
||||||
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
if (elements == 0)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrPointless);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
|
|
||||||
return;
|
|
||||||
|
|
||||||
while (elements--)
|
|
||||||
{
|
|
||||||
diff = *ptr_expected - *ptr_actual;
|
|
||||||
if (diff < 0.0)
|
|
||||||
diff = 0.0 - diff;
|
|
||||||
tol = UNITY_FLOAT_PRECISION * *ptr_expected;
|
|
||||||
if (tol < 0.0)
|
|
||||||
tol = 0.0 - tol;
|
|
||||||
if (diff > tol)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrElement);
|
|
||||||
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
|
|
||||||
#ifdef UNITY_FLOAT_VERBOSE
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintFloat(*ptr_expected);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintFloat(*ptr_actual);
|
|
||||||
#else
|
|
||||||
UnityPrint(UnityStrDelta);
|
|
||||||
#endif
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
ptr_expected++;
|
|
||||||
ptr_actual++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityAssertFloatsWithin(const _UF delta,
|
|
||||||
const _UF expected,
|
|
||||||
const _UF actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber)
|
|
||||||
{
|
|
||||||
_UF diff = actual - expected;
|
|
||||||
_UF pos_delta = delta;
|
|
||||||
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
if (diff < 0)
|
|
||||||
{
|
|
||||||
diff = 0.0f - diff;
|
|
||||||
}
|
|
||||||
if (pos_delta < 0)
|
|
||||||
{
|
|
||||||
pos_delta = 0.0f - pos_delta;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (pos_delta < diff)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
#ifdef UNITY_FLOAT_VERBOSE
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintFloat(expected);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintFloat(actual);
|
|
||||||
#else
|
|
||||||
UnityPrint(UnityStrDelta);
|
|
||||||
#endif
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityAssertNumbersWithin( const _U_SINT delta,
|
|
||||||
const _U_SINT expected,
|
|
||||||
const _U_SINT actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber,
|
|
||||||
const UNITY_DISPLAY_STYLE_T style)
|
|
||||||
{
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
|
|
||||||
{
|
|
||||||
if (actual > expected)
|
|
||||||
Unity.CurrentTestFailed = ((actual - expected) > delta);
|
|
||||||
else
|
|
||||||
Unity.CurrentTestFailed = ((expected - actual) > delta);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
if ((_U_UINT)actual > (_U_UINT)expected)
|
|
||||||
Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > (_U_UINT)delta);
|
|
||||||
else
|
|
||||||
Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > (_U_UINT)delta);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (Unity.CurrentTestFailed)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrDelta);
|
|
||||||
UnityPrintNumberByStyle(delta, style);
|
|
||||||
UnityPrint(UnityStrExpected);
|
|
||||||
UnityPrintNumberByStyle(expected, style);
|
|
||||||
UnityPrint(UnityStrWas);
|
|
||||||
UnityPrintNumberByStyle(actual, style);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityAssertEqualString(const char* expected,
|
|
||||||
const char* actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber)
|
|
||||||
{
|
|
||||||
_UU32 i;
|
|
||||||
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
// if both pointers not null compare the strings
|
|
||||||
if (expected && actual)
|
|
||||||
{
|
|
||||||
for (i = 0; expected[i] || actual[i]; i++)
|
|
||||||
{
|
|
||||||
if (expected[i] != actual[i])
|
|
||||||
{
|
|
||||||
Unity.CurrentTestFailed = 1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{ // handle case of one pointers being null (if both null, test should pass)
|
|
||||||
if (expected != actual)
|
|
||||||
{
|
|
||||||
Unity.CurrentTestFailed = 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (Unity.CurrentTestFailed)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrintExpectedAndActualStrings(expected, actual);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityAssertEqualStringArray( const char** expected,
|
|
||||||
const char** actual,
|
|
||||||
const _UU32 num_elements,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber)
|
|
||||||
{
|
|
||||||
_UU32 i, j = 0;
|
|
||||||
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
// if no elements, it's an error
|
|
||||||
if (num_elements == 0)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrPointless);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
|
|
||||||
return;
|
|
||||||
|
|
||||||
do
|
|
||||||
{
|
|
||||||
// if both pointers not null compare the strings
|
|
||||||
if (expected[j] && actual[j])
|
|
||||||
{
|
|
||||||
for (i = 0; expected[j][i] || actual[j][i]; i++)
|
|
||||||
{
|
|
||||||
if (expected[j][i] != actual[j][i])
|
|
||||||
{
|
|
||||||
Unity.CurrentTestFailed = 1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{ // handle case of one pointers being null (if both null, test should pass)
|
|
||||||
if (expected[j] != actual[j])
|
|
||||||
{
|
|
||||||
Unity.CurrentTestFailed = 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (Unity.CurrentTestFailed)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
if (num_elements > 1)
|
|
||||||
{
|
|
||||||
UnityPrint(UnityStrElement);
|
|
||||||
UnityPrintNumberByStyle((num_elements - j - 1), UNITY_DISPLAY_STYLE_UINT);
|
|
||||||
}
|
|
||||||
UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j]));
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
} while (++j < num_elements);
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityAssertEqualMemory( const void* expected,
|
|
||||||
const void* actual,
|
|
||||||
_UU32 length,
|
|
||||||
_UU32 num_elements,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber)
|
|
||||||
{
|
|
||||||
unsigned char* expected_ptr = (unsigned char*)expected;
|
|
||||||
unsigned char* actual_ptr = (unsigned char*)actual;
|
|
||||||
_UU32 elements = num_elements;
|
|
||||||
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
if ((elements == 0) || (length == 0))
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
UnityPrint(UnityStrPointless);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
|
|
||||||
return;
|
|
||||||
|
|
||||||
while (elements--)
|
|
||||||
{
|
|
||||||
if (memcmp((const void*)expected_ptr, (const void*)actual_ptr, length) != 0)
|
|
||||||
{
|
|
||||||
Unity.CurrentTestFailed = 1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
expected_ptr += length;
|
|
||||||
actual_ptr += length;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (Unity.CurrentTestFailed)
|
|
||||||
{
|
|
||||||
UnityTestResultsFailBegin(lineNumber);
|
|
||||||
if (num_elements > 1)
|
|
||||||
{
|
|
||||||
UnityPrint(UnityStrElement);
|
|
||||||
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
|
|
||||||
}
|
|
||||||
UnityPrint(UnityStrMemory);
|
|
||||||
UnityAddMsgIfSpecified(msg);
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
// Control Functions
|
|
||||||
//-----------------------------------------------
|
|
||||||
|
|
||||||
void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
|
|
||||||
{
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
UnityTestResultsBegin(Unity.TestFile, line);
|
|
||||||
UnityPrint("FAIL");
|
|
||||||
if (msg != NULL)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR(':');
|
|
||||||
if (msg[0] != ' ')
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR(' ');
|
|
||||||
}
|
|
||||||
UnityPrint(msg);
|
|
||||||
}
|
|
||||||
UNITY_FAIL_AND_BAIL;
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
|
|
||||||
{
|
|
||||||
UNITY_SKIP_EXECUTION;
|
|
||||||
|
|
||||||
UnityTestResultsBegin(Unity.TestFile, line);
|
|
||||||
UnityPrint("IGNORE");
|
|
||||||
if (msg != NULL)
|
|
||||||
{
|
|
||||||
UNITY_OUTPUT_CHAR(':');
|
|
||||||
UNITY_OUTPUT_CHAR(' ');
|
|
||||||
UnityPrint(msg);
|
|
||||||
}
|
|
||||||
UNITY_IGNORE_AND_BAIL;
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void setUp(void);
|
|
||||||
void tearDown(void);
|
|
||||||
void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
|
|
||||||
{
|
|
||||||
Unity.CurrentTestName = FuncName;
|
|
||||||
Unity.CurrentTestLineNumber = FuncLineNum;
|
|
||||||
Unity.NumberOfTests++;
|
|
||||||
if (TEST_PROTECT())
|
|
||||||
{
|
|
||||||
setUp();
|
|
||||||
Func();
|
|
||||||
}
|
|
||||||
if (TEST_PROTECT() && !(Unity.CurrentTestIgnored))
|
|
||||||
{
|
|
||||||
tearDown();
|
|
||||||
}
|
|
||||||
UnityConcludeTest();
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
void UnityBegin(void)
|
|
||||||
{
|
|
||||||
Unity.NumberOfTests = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
//-----------------------------------------------
|
|
||||||
int UnityEnd(void)
|
|
||||||
{
|
|
||||||
UnityPrint("-----------------------");
|
|
||||||
UNITY_PRINT_EOL;
|
|
||||||
UnityPrintNumber(Unity.NumberOfTests);
|
|
||||||
UnityPrint(" Tests ");
|
|
||||||
UnityPrintNumber(Unity.TestFailures);
|
|
||||||
UnityPrint(" Failures ");
|
|
||||||
UnityPrintNumber(Unity.TestIgnores);
|
|
||||||
UnityPrint(" Ignored");
|
|
||||||
UNITY_PRINT_EOL;
|
|
||||||
if (Unity.TestFailures == 0U)
|
|
||||||
{
|
|
||||||
UnityPrint("OK");
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
UnityPrint("FAIL");
|
|
||||||
}
|
|
||||||
UNITY_PRINT_EOL;
|
|
||||||
return Unity.TestFailures;
|
|
||||||
}
|
|
||||||
@@ -1,209 +0,0 @@
|
|||||||
/* ==========================================
|
|
||||||
Unity Project - A Test Framework for C
|
|
||||||
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
|
||||||
[Released under MIT License. Please refer to license.txt for details]
|
|
||||||
========================================== */
|
|
||||||
|
|
||||||
#ifndef UNITY_FRAMEWORK_H
|
|
||||||
#define UNITY_FRAMEWORK_H
|
|
||||||
|
|
||||||
#define UNITY
|
|
||||||
|
|
||||||
#include "unity_internals.h"
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Configuration Options
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
// Integers
|
|
||||||
// - Unity assumes 32 bit integers by default
|
|
||||||
// - If your compiler treats ints of a different size, define UNITY_INT_WIDTH
|
|
||||||
|
|
||||||
// Floats
|
|
||||||
// - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons
|
|
||||||
// - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT
|
|
||||||
// - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats
|
|
||||||
// - define UNITY_FLOAT_VERBOSE to print floating point values in errors (uses sprintf)
|
|
||||||
|
|
||||||
// Output
|
|
||||||
// - by default, Unity prints to standard out with putchar. define UNITY_OUTPUT_CHAR(a) with a different function if desired
|
|
||||||
|
|
||||||
// Optimization
|
|
||||||
// - by default, line numbers are stored in unsigned shorts. Define UNITY_LINE_TYPE with a different type if your files are huge
|
|
||||||
// - by default, test and failure counters are unsigned shorts. Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests.
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Test Running Macros
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0)
|
|
||||||
|
|
||||||
#define TEST_ABORT() {longjmp(Unity.AbortFrame, 1);}
|
|
||||||
|
|
||||||
#ifndef RUN_TEST
|
|
||||||
#define RUN_TEST(func, line_num) UnityDefaultTestRun(func, #func, line_num)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define TEST_LINE_NUM (Unity.CurrentTestLineNumber)
|
|
||||||
#define TEST_IS_IGNORED (Unity.CurrentTestIgnored)
|
|
||||||
|
|
||||||
#define TEST_CASE(...)
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Basic Fail and Ignore
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#define TEST_FAIL_MESSAGE(message) UNITY_TEST_FAIL(__LINE__, message)
|
|
||||||
#define TEST_FAIL() UNITY_TEST_FAIL(__LINE__, NULL)
|
|
||||||
#define TEST_IGNORE_MESSAGE(message) UNITY_TEST_IGNORE(__LINE__, message)
|
|
||||||
#define TEST_IGNORE() UNITY_TEST_IGNORE(__LINE__, NULL)
|
|
||||||
#define TEST_ONLY()
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Test Asserts (simple)
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
//Boolean
|
|
||||||
#define TEST_ASSERT(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expression Evaluated To FALSE")
|
|
||||||
#define TEST_ASSERT_TRUE(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expected TRUE Was FALSE")
|
|
||||||
#define TEST_ASSERT_UNLESS(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expression Evaluated To TRUE")
|
|
||||||
#define TEST_ASSERT_FALSE(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expected FALSE Was TRUE")
|
|
||||||
#define TEST_ASSERT_NULL(pointer) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, " Expected NULL")
|
|
||||||
#define TEST_ASSERT_NOT_NULL(pointer) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL")
|
|
||||||
|
|
||||||
//Integers (of all sizes)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal")
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX8(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX16(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX32(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX64(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_BITS(mask, expected, actual) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_BITS_HIGH(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(-1), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((_UU32)1 << bit), (_UU32)(-1), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((_UU32)1 << bit), (_UU32)(0), (actual), __LINE__, NULL)
|
|
||||||
|
|
||||||
//Integer Ranges (of all sizes)
|
|
||||||
#define TEST_ASSERT_INT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_UINT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_HEX_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, __LINE__, NULL)
|
|
||||||
|
|
||||||
//Structs and Strings
|
|
||||||
#define TEST_ASSERT_EQUAL_PTR(expected, actual) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_STRING(expected, actual) UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, __LINE__, NULL)
|
|
||||||
|
|
||||||
//Arrays
|
|
||||||
#define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, __LINE__, NULL)
|
|
||||||
|
|
||||||
//Floating Point (If Enabled)
|
|
||||||
#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, __LINE__, NULL)
|
|
||||||
#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, __LINE__, NULL)
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Test Asserts (with additional messages)
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
//Boolean
|
|
||||||
#define TEST_ASSERT_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_TRUE_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_UNLESS_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_FALSE_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, message)
|
|
||||||
|
|
||||||
//Integers (of all sizes)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(-1), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((_UU32)1 << bit), (_UU32)(-1), (actual), __LINE__, message)
|
|
||||||
#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((_UU32)1 << bit), (_UU32)(0), (actual), __LINE__, message)
|
|
||||||
|
|
||||||
//Integer Ranges (of all sizes)
|
|
||||||
#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_UINT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, __LINE__, message)
|
|
||||||
|
|
||||||
//Structs and Strings
|
|
||||||
#define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, __LINE__, message)
|
|
||||||
|
|
||||||
//Arrays
|
|
||||||
#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, __LINE__, message)
|
|
||||||
|
|
||||||
//Floating Point (If Enabled)
|
|
||||||
#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, __LINE__, message)
|
|
||||||
#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, __LINE__, message)
|
|
||||||
#endif
|
|
||||||
@@ -1,356 +0,0 @@
|
|||||||
/* ==========================================
|
|
||||||
Unity Project - A Test Framework for C
|
|
||||||
Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
|
|
||||||
[Released under MIT License. Please refer to license.txt for details]
|
|
||||||
========================================== */
|
|
||||||
|
|
||||||
#ifndef UNITY_INTERNALS_H
|
|
||||||
#define UNITY_INTERNALS_H
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <setjmp.h>
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Int Support
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#ifndef UNITY_INT_WIDTH
|
|
||||||
#define UNITY_INT_WIDTH (32)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef UNITY_LONG_WIDTH
|
|
||||||
#define UNITY_LONG_WIDTH (32)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if (UNITY_INT_WIDTH == 32)
|
|
||||||
typedef unsigned char _UU8;
|
|
||||||
typedef unsigned short _UU16;
|
|
||||||
typedef unsigned int _UU32;
|
|
||||||
typedef signed char _US8;
|
|
||||||
typedef signed short _US16;
|
|
||||||
typedef signed int _US32;
|
|
||||||
#elif (UNITY_INT_WIDTH == 16)
|
|
||||||
typedef unsigned char _UU8;
|
|
||||||
typedef unsigned int _UU16;
|
|
||||||
typedef unsigned long _UU32;
|
|
||||||
typedef signed char _US8;
|
|
||||||
typedef signed int _US16;
|
|
||||||
typedef signed long _US32;
|
|
||||||
#else
|
|
||||||
#error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// 64-bit Support
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#ifndef UNITY_SUPPORT_64
|
|
||||||
|
|
||||||
//No 64-bit Support
|
|
||||||
typedef _UU32 _U_UINT;
|
|
||||||
typedef _US32 _U_SINT;
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
//64-bit Support
|
|
||||||
#if (UNITY_LONG_WIDTH == 32)
|
|
||||||
typedef unsigned long long _UU64;
|
|
||||||
typedef signed long long _US64;
|
|
||||||
#elif (UNITY_LONG_WIDTH == 64)
|
|
||||||
typedef unsigned long _UU64;
|
|
||||||
typedef signed long _US64;
|
|
||||||
#else
|
|
||||||
#error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported)
|
|
||||||
#endif
|
|
||||||
typedef _UU64 _U_UINT;
|
|
||||||
typedef _US64 _U_SINT;
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Pointer Support
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#ifndef UNITY_POINTER_WIDTH
|
|
||||||
#define UNITY_POINTER_WIDTH (32)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if (UNITY_POINTER_WIDTH == 32)
|
|
||||||
typedef _UU32 _UP;
|
|
||||||
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32
|
|
||||||
#elif (UNITY_POINTER_WIDTH == 64)
|
|
||||||
typedef _UU64 _UP;
|
|
||||||
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64
|
|
||||||
#elif (UNITY_POINTER_WIDTH == 16)
|
|
||||||
typedef _UU16 _UP;
|
|
||||||
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16
|
|
||||||
#else
|
|
||||||
#error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Float Support
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#ifdef UNITY_EXCLUDE_FLOAT
|
|
||||||
|
|
||||||
//No Floating Point Support
|
|
||||||
#undef UNITY_FLOAT_PRECISION
|
|
||||||
#undef UNITY_FLOAT_TYPE
|
|
||||||
#undef UNITY_FLOAT_VERBOSE
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
//Floating Point Support
|
|
||||||
#ifndef UNITY_FLOAT_PRECISION
|
|
||||||
#define UNITY_FLOAT_PRECISION (0.00001f)
|
|
||||||
#endif
|
|
||||||
#ifndef UNITY_FLOAT_TYPE
|
|
||||||
#define UNITY_FLOAT_TYPE float
|
|
||||||
#endif
|
|
||||||
typedef UNITY_FLOAT_TYPE _UF;
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Output Method
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#ifndef UNITY_OUTPUT_CHAR
|
|
||||||
//Default to using putchar, which is defined in stdio.h above
|
|
||||||
#define UNITY_OUTPUT_CHAR(a) putchar(a)
|
|
||||||
#else
|
|
||||||
//If defined as something else, make sure we declare it here so it's ready for use
|
|
||||||
extern int UNITY_OUTPUT_CHAR(int);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Footprint
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#ifndef UNITY_LINE_TYPE
|
|
||||||
#define UNITY_LINE_TYPE unsigned short
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef UNITY_COUNTER_TYPE
|
|
||||||
#define UNITY_COUNTER_TYPE unsigned short
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Internal Structs Needed
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
typedef void (*UnityTestFunction)(void);
|
|
||||||
|
|
||||||
#define UNITY_DISPLAY_RANGE_INT (0x10)
|
|
||||||
#define UNITY_DISPLAY_RANGE_UINT (0x20)
|
|
||||||
#define UNITY_DISPLAY_RANGE_HEX (0x40)
|
|
||||||
#define UNITY_DISPLAY_RANGE_AUTO (0x80)
|
|
||||||
|
|
||||||
typedef enum
|
|
||||||
{
|
|
||||||
UNITY_DISPLAY_STYLE_INT = 4 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
|
|
||||||
UNITY_DISPLAY_STYLE_INT8 = 1 + UNITY_DISPLAY_RANGE_INT,
|
|
||||||
UNITY_DISPLAY_STYLE_INT16 = 2 + UNITY_DISPLAY_RANGE_INT,
|
|
||||||
UNITY_DISPLAY_STYLE_INT32 = 4 + UNITY_DISPLAY_RANGE_INT,
|
|
||||||
#ifdef UNITY_SUPPORT_64
|
|
||||||
UNITY_DISPLAY_STYLE_INT64 = 8 + UNITY_DISPLAY_RANGE_INT,
|
|
||||||
#endif
|
|
||||||
UNITY_DISPLAY_STYLE_UINT = 4 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
|
|
||||||
UNITY_DISPLAY_STYLE_UINT8 = 1 + UNITY_DISPLAY_RANGE_UINT,
|
|
||||||
UNITY_DISPLAY_STYLE_UINT16 = 2 + UNITY_DISPLAY_RANGE_UINT,
|
|
||||||
UNITY_DISPLAY_STYLE_UINT32 = 4 + UNITY_DISPLAY_RANGE_UINT,
|
|
||||||
#ifdef UNITY_SUPPORT_64
|
|
||||||
UNITY_DISPLAY_STYLE_UINT64 = 8 + UNITY_DISPLAY_RANGE_UINT,
|
|
||||||
#endif
|
|
||||||
UNITY_DISPLAY_STYLE_HEX8 = 1 + UNITY_DISPLAY_RANGE_HEX,
|
|
||||||
UNITY_DISPLAY_STYLE_HEX16 = 2 + UNITY_DISPLAY_RANGE_HEX,
|
|
||||||
UNITY_DISPLAY_STYLE_HEX32 = 4 + UNITY_DISPLAY_RANGE_HEX,
|
|
||||||
#ifdef UNITY_SUPPORT_64
|
|
||||||
UNITY_DISPLAY_STYLE_HEX64 = 8 + UNITY_DISPLAY_RANGE_HEX,
|
|
||||||
#endif
|
|
||||||
} UNITY_DISPLAY_STYLE_T;
|
|
||||||
|
|
||||||
struct _Unity
|
|
||||||
{
|
|
||||||
const char* TestFile;
|
|
||||||
const char* CurrentTestName;
|
|
||||||
_UU32 CurrentTestLineNumber;
|
|
||||||
UNITY_COUNTER_TYPE NumberOfTests;
|
|
||||||
UNITY_COUNTER_TYPE TestFailures;
|
|
||||||
UNITY_COUNTER_TYPE TestIgnores;
|
|
||||||
UNITY_COUNTER_TYPE CurrentTestFailed;
|
|
||||||
UNITY_COUNTER_TYPE CurrentTestIgnored;
|
|
||||||
jmp_buf AbortFrame;
|
|
||||||
};
|
|
||||||
|
|
||||||
extern struct _Unity Unity;
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Test Suite Management
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
void UnityBegin(void);
|
|
||||||
int UnityEnd(void);
|
|
||||||
|
|
||||||
void UnityConcludeTest(void);
|
|
||||||
void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum);
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Test Output
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
void UnityPrint(const char* string);
|
|
||||||
void UnityPrintMask(const _U_UINT mask, const _U_UINT number);
|
|
||||||
void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style);
|
|
||||||
void UnityPrintNumber(const _U_SINT number);
|
|
||||||
void UnityPrintNumberUnsigned(const _U_UINT number);
|
|
||||||
void UnityPrintNumberHex(const _U_UINT number, const char nibbles);
|
|
||||||
|
|
||||||
#ifdef UNITY_FLOAT_VERBOSE
|
|
||||||
void UnityPrintFloat(const _UF number);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Test Assertion Fuctions
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Use the macros below this section instead of calling
|
|
||||||
// these directly. The macros have a consistent naming
|
|
||||||
// convention and will pull in file and line information
|
|
||||||
// for you.
|
|
||||||
|
|
||||||
void UnityAssertEqualNumber(const _U_SINT expected,
|
|
||||||
const _U_SINT actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber,
|
|
||||||
const UNITY_DISPLAY_STYLE_T style);
|
|
||||||
|
|
||||||
void UnityAssertEqualIntArray(const _U_SINT* expected,
|
|
||||||
const _U_SINT* actual,
|
|
||||||
const _UU32 num_elements,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber,
|
|
||||||
const UNITY_DISPLAY_STYLE_T style);
|
|
||||||
|
|
||||||
void UnityAssertBits(const _U_SINT mask,
|
|
||||||
const _U_SINT expected,
|
|
||||||
const _U_SINT actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber);
|
|
||||||
|
|
||||||
void UnityAssertEqualString(const char* expected,
|
|
||||||
const char* actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber);
|
|
||||||
|
|
||||||
void UnityAssertEqualStringArray( const char** expected,
|
|
||||||
const char** actual,
|
|
||||||
const _UU32 num_elements,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber);
|
|
||||||
|
|
||||||
void UnityAssertEqualMemory( const void* expected,
|
|
||||||
const void* actual,
|
|
||||||
const _UU32 length,
|
|
||||||
const _UU32 num_elements,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber);
|
|
||||||
|
|
||||||
void UnityAssertNumbersWithin(const _U_SINT delta,
|
|
||||||
const _U_SINT expected,
|
|
||||||
const _U_SINT actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber,
|
|
||||||
const UNITY_DISPLAY_STYLE_T style);
|
|
||||||
|
|
||||||
void UnityFail(const char* message, const UNITY_LINE_TYPE line);
|
|
||||||
|
|
||||||
void UnityIgnore(const char* message, const UNITY_LINE_TYPE line);
|
|
||||||
|
|
||||||
#ifndef UNITY_EXCLUDE_FLOAT
|
|
||||||
void UnityAssertFloatsWithin(const _UF delta,
|
|
||||||
const _UF expected,
|
|
||||||
const _UF actual,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber);
|
|
||||||
|
|
||||||
void UnityAssertEqualFloatArray(const _UF* expected,
|
|
||||||
const _UF* actual,
|
|
||||||
const _UU32 num_elements,
|
|
||||||
const char* msg,
|
|
||||||
const UNITY_LINE_TYPE lineNumber);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Basic Fail and Ignore
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#define UNITY_TEST_FAIL(line, message) UnityFail( (message), (UNITY_LINE_TYPE)line);
|
|
||||||
#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)line);
|
|
||||||
|
|
||||||
//-------------------------------------------------------
|
|
||||||
// Test Asserts
|
|
||||||
//-------------------------------------------------------
|
|
||||||
|
|
||||||
#define UNITY_TEST_ASSERT(condition, line, message) if (condition) {} else {UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, message);}
|
|
||||||
#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (UNITY_LINE_TYPE)line, message)
|
|
||||||
#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (UNITY_LINE_TYPE)line, message)
|
|
||||||
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
|
|
||||||
#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((_U_SINT)(mask), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line)
|
|
||||||
|
|
||||||
#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
|
|
||||||
#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
|
|
||||||
#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8)
|
|
||||||
#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16)
|
|
||||||
#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
|
|
||||||
#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX64)
|
|
||||||
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_UP)(expected), (_U_SINT)(_UP)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_POINTER)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, line, message) UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)line)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message) UnityAssertEqualMemory((void*)(expected), (void*)(actual), (_UU32)(len), 1, (message), (UNITY_LINE_TYPE)line)
|
|
||||||
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT8)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT16)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT32)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT8)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT16)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT32)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((const char**)(expected), (const char**)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((void*)(expected), (void*)(actual), (_UU32)(len), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
|
|
||||||
|
|
||||||
#ifdef UNITY_SUPPORT_64
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT64)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT64)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX64)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT64)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT64)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX64)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef UNITY_EXCLUDE_FLOAT
|
|
||||||
#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
|
|
||||||
#else
|
|
||||||
#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((_UF)(delta), (_UF)(expected), (_UF)(actual), (message), (UNITY_LINE_TYPE)line)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((_UF)(expected) * (_UF)UNITY_FLOAT_PRECISION, (_UF)expected, (_UF)actual, (UNITY_LINE_TYPE)line, message)
|
|
||||||
#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((_UF*)(expected), (_UF*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,97 +0,0 @@
|
|||||||
#include "unity_test_module.h"
|
|
||||||
#include <string.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdbool.h>
|
|
||||||
#include "unity.h"
|
|
||||||
|
|
||||||
void (*unity_setUp_ptr)(void) = NULL;
|
|
||||||
void (*unit_tearDown_ptr)(void) = NULL;
|
|
||||||
|
|
||||||
#ifdef UNITY_USE_MODULE_SETUP_TEARDOWN
|
|
||||||
|
|
||||||
void setUp()
|
|
||||||
{
|
|
||||||
if(unity_setUp_ptr != NULL) unity_setUp_ptr();
|
|
||||||
}
|
|
||||||
|
|
||||||
void tearDown()
|
|
||||||
{
|
|
||||||
if(unit_tearDown_ptr != NULL) unit_tearDown_ptr();
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void UnityRegisterSetupTearDown( void(*setUp)(void), void(*tearDown)(void) )
|
|
||||||
{
|
|
||||||
unity_setUp_ptr = setUp;
|
|
||||||
unit_tearDown_ptr = tearDown;
|
|
||||||
}
|
|
||||||
|
|
||||||
void UnityUnregisterSetupTearDown(void)
|
|
||||||
{
|
|
||||||
unity_setUp_ptr = NULL;
|
|
||||||
unit_tearDown_ptr = NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
UnityTestModule* UnityTestModuleFind(
|
|
||||||
UnityTestModule* modules,
|
|
||||||
size_t number_of_modules,
|
|
||||||
char* wantedModule)
|
|
||||||
{
|
|
||||||
for(size_t i = 0; i < number_of_modules; i++) {
|
|
||||||
if(strcmp(wantedModule, modules[i].name) == 0) {
|
|
||||||
return &modules[i];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
void UnityTestModuleRunRequestedModules(
|
|
||||||
int number_of_requested_modules,
|
|
||||||
char* requested_modules_names[],
|
|
||||||
UnityTestModule* allModules,
|
|
||||||
size_t number_of_modules )
|
|
||||||
{
|
|
||||||
for(int i = 0; i < number_of_requested_modules; i++)
|
|
||||||
{
|
|
||||||
UnityTestModule* module = UnityTestModuleFind(allModules,
|
|
||||||
number_of_modules, requested_modules_names[i]);
|
|
||||||
|
|
||||||
if(module != NULL)
|
|
||||||
{
|
|
||||||
module->run_tests();
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
printf("Ignoring: could not find requested module: %s\n",
|
|
||||||
requested_modules_names[i]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int UnityTestModuleRun(
|
|
||||||
int argc,
|
|
||||||
char * argv[],
|
|
||||||
UnityTestModule* allModules,
|
|
||||||
size_t number_of_modules)
|
|
||||||
{
|
|
||||||
UnityBegin();
|
|
||||||
|
|
||||||
bool moduleRequests = (argc > 1);
|
|
||||||
|
|
||||||
if(moduleRequests)
|
|
||||||
{
|
|
||||||
UnityTestModuleRunRequestedModules(argc-1, &argv[1],
|
|
||||||
allModules, number_of_modules);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
for(int i = 0; i < number_of_modules; i++)
|
|
||||||
{
|
|
||||||
allModules[i].run_tests();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return UnityEnd();
|
|
||||||
}
|
|
||||||
@@ -1,31 +0,0 @@
|
|||||||
#ifndef UNITY_TEST_MODULE_H
|
|
||||||
#define UNITY_TEST_MODULE_H
|
|
||||||
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
typedef struct {
|
|
||||||
char name[24];
|
|
||||||
void(*run_tests)(void);
|
|
||||||
} UnityTestModule;
|
|
||||||
|
|
||||||
void UnityRegisterSetupTearDown( void(*setUp)(void), void(*tearDown)(void) );
|
|
||||||
void UnityUnregisterSetupTearDown(void);
|
|
||||||
|
|
||||||
UnityTestModule* UnityTestModuleFind(
|
|
||||||
UnityTestModule* modules,
|
|
||||||
size_t number_of_modules,
|
|
||||||
char* wantedModule);
|
|
||||||
|
|
||||||
void UnityTestModuleRunRequestedModules(
|
|
||||||
int number_of_requested_modules,
|
|
||||||
char* requested_modules_names[],
|
|
||||||
UnityTestModule* allModules,
|
|
||||||
size_t number_of_modules );
|
|
||||||
|
|
||||||
int UnityTestModuleRun(
|
|
||||||
int argc,
|
|
||||||
char * argv[],
|
|
||||||
UnityTestModule* allModules,
|
|
||||||
size_t number_of_modules);
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,6 +0,0 @@
|
|||||||
{
|
|
||||||
"challenge":{
|
|
||||||
"level":["knows"] ,
|
|
||||||
"durationHours": 4
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,22 +0,0 @@
|
|||||||
#include <stdio.h>
|
|
||||||
#include "calculations.h"
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
// from her your program starts
|
|
||||||
int variableWithAName = 14;
|
|
||||||
int variableWithAnotherName = 12;
|
|
||||||
|
|
||||||
int result = swap(&variableWithAName, &variableWithAnotherName);
|
|
||||||
|
|
||||||
if (result==0)
|
|
||||||
{
|
|
||||||
printf("succeeded\n");
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
printf("failed, the implementation is empty\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
return (0);
|
|
||||||
}
|
|
||||||
@@ -1,15 +0,0 @@
|
|||||||
#include "calculations.h"
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
int swap(int* getal1, int* getal2)
|
|
||||||
{
|
|
||||||
if(getal1 == NULL || getal2==NULL)
|
|
||||||
{
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
//TODO insert code here
|
|
||||||
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
}
|
|
||||||
@@ -1,16 +0,0 @@
|
|||||||
#ifndef CALCULATIONS_H
|
|
||||||
#define CALCULATIONS_H
|
|
||||||
|
|
||||||
#include <stdint.h>
|
|
||||||
|
|
||||||
// return
|
|
||||||
// 0 : swap gelukt
|
|
||||||
//-1 : fout opgtreden
|
|
||||||
|
|
||||||
int swap(int* getal1, int* getal2);
|
|
||||||
|
|
||||||
// 0 : GELUKT
|
|
||||||
// -1 : er is iets mis gegaan
|
|
||||||
int sort (int array[]);
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,76 +0,0 @@
|
|||||||
/*
|
|
||||||
* auteur : Freddy Hurkmans
|
|
||||||
* datum : November 15th 2015
|
|
||||||
* code : C99
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#include "calculations.h"
|
|
||||||
#include "unity.h"
|
|
||||||
|
|
||||||
// I rather dislike keeping line numbers updated, so I made my own macro to ditch the line number
|
|
||||||
#define MY_RUN_TEST(func) RUN_TEST(func, 0)
|
|
||||||
|
|
||||||
void setUp(void)
|
|
||||||
{
|
|
||||||
// This is run before EACH test
|
|
||||||
}
|
|
||||||
|
|
||||||
void tearDown(void)
|
|
||||||
{
|
|
||||||
// This is run after EACH test
|
|
||||||
}
|
|
||||||
|
|
||||||
void test_to_see_if_our_compiler_can_add_2_integers(void)
|
|
||||||
{
|
|
||||||
int result = 2;
|
|
||||||
TEST_ASSERT_EQUAL(result, 1+1);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
void testswap()
|
|
||||||
{
|
|
||||||
int getal1 =15;
|
|
||||||
int getal2 = 20;
|
|
||||||
int *getalptr = NULL;
|
|
||||||
getalptr = &getal1;
|
|
||||||
|
|
||||||
int result = swap(getalptr,&getal2);
|
|
||||||
TEST_ASSERT_EQUAL(0,result);
|
|
||||||
TEST_ASSERT_EQUAL(20,getal1);
|
|
||||||
TEST_ASSERT_EQUAL(15,getal2);
|
|
||||||
|
|
||||||
getal1 =0;
|
|
||||||
getal2 = 0;
|
|
||||||
result = swap(&getal1,&getal2);
|
|
||||||
TEST_ASSERT_EQUAL(0,result);
|
|
||||||
TEST_ASSERT_EQUAL(0,getal1);
|
|
||||||
TEST_ASSERT_EQUAL(0,getal2);
|
|
||||||
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void testswapptrnull()
|
|
||||||
{
|
|
||||||
int getal1 =15;
|
|
||||||
int getal2 = 20;
|
|
||||||
int result = swap(&getal1,NULL);
|
|
||||||
TEST_ASSERT_EQUAL(-1,result);
|
|
||||||
result = swap(NULL,&getal2);
|
|
||||||
TEST_ASSERT_EQUAL(-1,result);
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int main (int argc, char * argv[])
|
|
||||||
{
|
|
||||||
UnityBegin();
|
|
||||||
|
|
||||||
MY_RUN_TEST(test_to_see_if_our_compiler_can_add_2_integers);
|
|
||||||
|
|
||||||
MY_RUN_TEST(testswap);
|
|
||||||
MY_RUN_TEST (testswapptrnull);
|
|
||||||
|
|
||||||
return UnityEnd();
|
|
||||||
}
|
|
||||||
108
README.md
108
README.md
@@ -1,93 +1,45 @@
|
|||||||
# T2
|
# School Projects - Term 2
|
||||||
|
|
||||||
|
Welcome to my repository containing all school projects for Term 2. These projects are organized by subject and cover a wide range of programming and engineering concepts.
|
||||||
|
|
||||||
|
## Subjects & Projects
|
||||||
|
|
||||||
## Getting started
|
### 1. Procedural Programming (C Language)
|
||||||
|
Projects focusing on structured programming using C. Key topics include functions, arrays, structures, file handling, and more.
|
||||||
|
|
||||||
To make it easy for you to get started with GitLab, here's a list of recommended next steps.
|
**Projects:**
|
||||||
|
- Bike Computer (`C1 bike computer.zip`)
|
||||||
|
- Animal Shelter Management System (`C2 AnimalShelter.zip`)
|
||||||
|
- Adidas Themed Application (`C5 Adidas.zip`)
|
||||||
|
- Workshop exercises (in `t-oer-prc2-cbdb-main` folder)
|
||||||
|
|
||||||
Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
|
### 2. Object-Oriented Programming (C#)
|
||||||
|
Projects in this section emphasize object-oriented principles such as classes, inheritance, encapsulation, and polymorphism.
|
||||||
|
|
||||||
## Add your files
|
**(Add your C# projects here if available in the repo)**
|
||||||
|
|
||||||
- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
|
### 3. Embedded Systems (C++ / Physical Registers)
|
||||||
- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
|
Projects and exercises for embedded systems, focusing on low-level programming with direct hardware manipulation, register-level coding, and microcontroller interactions.
|
||||||
|
|
||||||
```
|
**(Add embedded system projects here if available in the repo)**
|
||||||
cd existing_repo
|
|
||||||
git remote add origin https://git.fhict.nl/I555408/T2.git
|
|
||||||
git branch -M main
|
|
||||||
git push -uf origin main
|
|
||||||
```
|
|
||||||
|
|
||||||
## Integrate with your tools
|
---
|
||||||
|
|
||||||
- [ ] [Set up project integrations](https://git.fhict.nl/I555408/T2/-/settings/integrations)
|
## Getting Started
|
||||||
|
|
||||||
## Collaborate with your team
|
Each project folder may contain a zipped archive. To run a project:
|
||||||
|
1. Extract the corresponding `.zip` file. *(if needed)*
|
||||||
|
2. Open the project in an appropriate IDE (e.g., Code::Blocks for C, Visual Studio for C#).
|
||||||
|
|
||||||
- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
|
## Technologies Used
|
||||||
- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
|
- C (Procedural Programming)
|
||||||
- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
|
- C# (Object-Oriented Programming)
|
||||||
- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
|
- C++ and Hardware (Embedded Systems)
|
||||||
- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
|
|
||||||
|
|
||||||
## Test and Deploy
|
## Author
|
||||||
|
Rens Pastoor
|
||||||
|
PCN: 555408
|
||||||
|
|
||||||
Use the built-in continuous integration in GitLab.
|
---
|
||||||
|
|
||||||
- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
|
Feel free to explore each folder and get hands-on with code, documentation, and electrical simulations!
|
||||||
- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
|
|
||||||
- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
|
|
||||||
- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
|
|
||||||
- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
|
|
||||||
|
|
||||||
***
|
|
||||||
|
|
||||||
# Editing this README
|
|
||||||
|
|
||||||
When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
|
|
||||||
|
|
||||||
## Suggestions for a good README
|
|
||||||
|
|
||||||
Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
|
|
||||||
|
|
||||||
## Name
|
|
||||||
Choose a self-explaining name for your project.
|
|
||||||
|
|
||||||
## Description
|
|
||||||
Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
|
|
||||||
|
|
||||||
## Badges
|
|
||||||
On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
|
|
||||||
|
|
||||||
## Visuals
|
|
||||||
Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
|
|
||||||
|
|
||||||
## Installation
|
|
||||||
Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
|
|
||||||
|
|
||||||
## Usage
|
|
||||||
Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
|
|
||||||
|
|
||||||
## Support
|
|
||||||
Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
|
|
||||||
|
|
||||||
## Roadmap
|
|
||||||
If you have ideas for releases in the future, it is a good idea to list them in the README.
|
|
||||||
|
|
||||||
## Contributing
|
|
||||||
State if you are open to contributions and what your requirements are for accepting them.
|
|
||||||
|
|
||||||
For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
|
|
||||||
|
|
||||||
You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
|
|
||||||
|
|
||||||
## Authors and acknowledgment
|
|
||||||
Show your appreciation to those who have contributed to the project.
|
|
||||||
|
|
||||||
## License
|
|
||||||
For open source projects, say how it is licensed.
|
|
||||||
|
|
||||||
## Project status
|
|
||||||
If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
|
|
||||||
|
|||||||
Reference in New Issue
Block a user