trackler 2.2.1.59 → 2.2.1.60

data/problem-specifications/exercises/two-bucket/description.md

@@ -5,15 +5,15 @@ Since this mathematical problem is fairly subject to interpretation / individual
 To help, the tests provide you with which bucket to fill first. That means, when starting with the larger bucket full, you are NOT allowed at any point to have the smaller bucket full and the larger bucket empty (aka, the opposite starting point); that would defeat the purpose of comparing both approaches!
 
 Your program will take as input:
-- the size of bucket one, passed as a numeric value
-- the size of bucket two, passed as a numeric value
-- the desired number of liters to reach, passed as a numeric value
-- which bucket to fill first, passed as a String (either 'one' or 'two')
+- the size of bucket one
+- the size of bucket two
+- the desired number of liters to reach
+- which bucket to fill first, either bucket one or bucket two
 
 Your program should determine:
-- the total number of "moves" it should take to reach the desired number of liters, including the first fill - expects a numeric value
-- which bucket should end up with the desired number of liters (let's say this is bucket A) - expects a String (either 'one' or 'two')
-- how many liters are left in the other bucket (bucket B) - expects a numeric value
+- the total number of "moves" it should take to reach the desired number of liters, including the first fill
+- which bucket should end up with the desired number of liters (let's say this is bucket A) - either bucket one or bucket two
+- how many liters are left in the other bucket (bucket B)
 
 Note: any time a change is made to either or both buckets counts as one (1) move.
 

data/tracks/c/docs/CONTRIBUTING.md

@@ -1,22 +1,71 @@
 # Contributing to the C Track
 
 Thank you for interest in contributing to the Exercism C language track! 
-All contributions are welcome, be it a new exercise, a change to the tooling or documentation, a raised issue or even just a commment on an existing issue or PR.
+All contributions are welcome, be it a new exercise, a change to the tooling or documentation, a raised issue or even just a comment on an existing issue or PR.
 This file provides information to help you get started.
 
 Firstly, have a read of the Exercism [docs repository](https://github.com/exercism/docs), specifically the information on [contributing to a language track](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/README.md), as these documents cover a lot of the basic information.
 
 Subsequently note that there are a few things specific to this repository that are explained below.
 
+We encourage contributions that provide fixes and improvements to existing exercises. 
+Please note that this track's exercises must conform to the standards determined in the [problem-specifications](https://github.com/exercism/problem-specifications) repository.
+Changes to the tests or documentation of a common exercise will often warrant a pull request in that repository before it can be incorporated into this track's exercises. 
+If you're unsure, then go ahead and open a GitHub [issue](https://github.com/exercism/c/blob/master/docs/CONTRIBUTING.md#issues), and we'll discuss the change.
+
+## Code of Conduct
+
+Help us keep Exercism welcoming.
+Please read and abide by the [Code of Conduct](https://github.com/exercism/exercism.io/blob/master/CODE_OF_CONDUCT.md).
+
+## Git Workflow
+
+1. Fork and clone.
+2. Add this repository as a new remote to your clone: `git remote add upstream https://github.com/exercism/c.git`
+3. Create a new branch: `git checkout -b name-of-branch`
+4. Commit and push as usual on your new branch
+5. When you're ready to submit a pull request, rebase your branch onto the upstream master so that you can resolve any conflicts: `git fetch upstream && git rebase upstream/master` You may need to push up to your branch using `--force` after resolving conflicts.
+6. When you've got everything ready, push up to your branch and create the pull request as outlined below.
+
+## Issues
+
+We keep track of bugs, enhancements and support requests in the repository using GitHub [issues](https://github.com/exercism/c/issues).
+
+For higher-level discussions about the project as a whole, check out the issues in the [discussions](https://github.com/exercism/discussions/issues) repository.
+
+### Good First Patch
+
+We're trying to label issues with "good first patch" if we think that these can be solved without too much context about Exercism's codebase or functionality. To find them, you can do a [search](https://github.com/exercism/c/good-first-patch).
+
+## Pull Requests
+
+It would be awesome if you follow these [simple guidelines](https://github.com/exercism/docs/blob/master/contributing/pull-request-guidelines.md) while creating your PR, but it isn't required.
+
+Pull requests should be focused on a single, issue or change.
+We welcome changes to code style and wording but please open a separate PR for these changes if possible.
+Please open an issue before creating a PR that makes significant (breaking) changes to an existing exercise or makes changes across many exercises. It is best to discuss these changes before doing the work.
+
+If your change is to an exercise you can run the CI scripts before submitting the pull request, or they will be automatically run after, as described in [Continuous Integration & Tests](https://github.com/exercism/c/blob/master/docs/CONTRIBUTING.md#continuous-integration--tests) 
+
+When submitting a pull request, sometimes we will ask you to make changes before we accept the patch.
+
+Please do not close the first pull request and open a second one with these changes.
+If you push more commits to a branch that you've opened a pull request for, it automatically updates the pull request.
+
+If you want to create a PR with changes that aren't quite ready to be merged to master yet (maybe you would like to discuss some particular item, for example), create the PR as normal but add `[WIP]` to the title so that maintainers know that it isn't quite ready to be merged just yet.
+
+As with adding more commits, you do not need to close your pull request and open a new one if you change the history (rebase, squash, amend), and use git push --force to update the branch on your fork. 
+The pull request points to that branch, not to specific commits.
+
 ## Coding Style
 
-The code style expected for code change contributions is explained in the [style guide](https://github.com/exercism/c/blob/master/docs/C_STYLE_GUIDE.md#indentation-and-format). 
-In short, they equate to the [Linux kernel coding style](https://www.kernel.org/doc/html/latest/process/coding-style.html) with 3 space indents and no tabs, and snake cased names.
+The code style expected for code change contributions is explained in the [style guide](https://github.com/exercism/c/blob/master/docs/C_STYLE_GUIDE.md).
 
-The exercise code is checked during CI for conformance to the spacing and indentation style rules. The check uses the GNU `indent` CLI tool.
-When adding or making a change to an exercise, you can check that your change conforms to these rules by running the tool locally before commiting.
+The exercise code is checked during [CI](https://github.com/exercism/c/blob/master/docs/CONTRIBUTING.md#continuous-integration--tests) for conformance to the spacing and indentation style rules. 
+The check uses the GNU `indent` CLI tool.
+When adding or making a change to an exercise, you can check that your change conforms to these rules by running the tool locally before committing.
 
-On linux `indent` should be available for install via your distribution's package manager. 
+On Linux `indent` should be available for install via your distribution's package manager. 
 On a Mac you can install the package `gnu-indent` using [Homebrew](https://brew.sh).
 
 Indent can be run on all files by executing `indent.sh`.
@@ -32,10 +81,37 @@ If your system does not support the `-linux` option, you can run the long-form c
 indent -nbad -bap -nbc -bbo -hnl -br -brs -c33 -cd33 -ncdb -ce -ci4 -cli0 -d0 -di1 -nfc1 -i3 -nut -ip0 -l80 -lp -npcs -nprs -npsl -sai -saf -saw -ncs -nsc -sob -nfca -cp33 -ss -il1 $(file)
 ```
 
-## Continuous Integration
+## Exercise anatomy
+
+Each exercise should be contained in a directory `c/exercises/<my exercise>` with `<my exercise>` referring to the name of the exercise. 
+The structure of the directory is as follows:
+
+```
++-- <my exercise>
+    +-- makefile
+    +-- src
+    |   +-- example.c
+    |   +-- example.h | <my exercise>.h
+    +-- test
+        +-- test_<my exercise>.c
+        +-- vendor
+            +-- unity.c
+            +-- unity.h
+            +-- unity_internals.h
+```
+
+* `test` - contains the test file `test_<my exercise>.c` and a `vendor` directory containing the test harness [Unity](http://www.throwtheswitch.org/unity/) from [ThrowTheSwitch](http://www.throwtheswitch.org/#intro-1-section).
+ThrowTheSwitch has a decent guide on [getting started with Unity](http://www.throwtheswitch.org/getting-started-with-unity/) should you desire a tutorial. The layout of the test file is described in the [style guide](https://github.com/exercism/c/blob/master/docs/C_STYLE_GUIDE.md#test-file-layout).
+
+* `src` - contains the example files `example.c` and `example.h`. These are both skipped by the `exercism` CLI when downloading to the client, so it is imperative that you do not reference the names of the files in your code. 
+If you need to provide a header file example that is necessary to run your tests it should be named `<my exercise>.h` instead.
+Please also use [`include`](http://faculty.cs.niu.edu/~mcmahon/CS241/c241man/node90.html) guards in your header files. 
+The [tests](https://github.com/exercism/c/blob/master/docs/CONTRIBUTING.md#what-are-the-ci-scripts) can be run using the [`bin/run-tests`](https://github.com/exercism/c/blob/master/bin/run-tests) script which will rename the `example.{c|h}` files accordingly.
+
+## Continuous Integration & Tests
 
 The repository uses Travis CI to run some scripts on each commit to a pull request. 
-The simplest way to run these scripts on your own contribution is to open a PR on this repository with your changes, mark the title as [WIP] so that maintainers know that it isn't quite ready to be merged just yet and then allow this repository's CI setup to take care of things for you automatically.
+The simplest way to run these scripts on your own contribution is to open a PR on this repository with your changes, edit the PR title to add `[WIP]` then allow this repository's CI setup to take care of things for you automatically.
 
 ### Run CI on Your Own Fork
 
@@ -43,8 +119,8 @@ If you would like, it is also possible to run Travis on your own fork.
 The good folks at fish-shell have [some great information](https://github.com/fish-shell/fish-shell/blob/master/CONTRIBUTING.md#travis-ci-build-and-test) to help you get started with setting up Travis on your own fork.
 
 ### Run CI Scripts Locally
-You can also run individual scripts on your own machine before commiting. 
-Firstly make sure you have the necessary tools installed (such as `indent`, `git`, `sed`, `make`, `valgrind` and a C compiler), and then run the required script from the repoistory root. For example:
+You can also run individual scripts on your own machine before committing. 
+Firstly make sure you have the necessary tools installed (such as `indent`, [`git`](https://git-scm.com/), [`sed`](https://www.gnu.org/software/sed/manual/sed.html), [`make`](https://www.gnu.org/software/make/), [`valgrind`](http://valgrind.org/) and a C compiler), and then run the required script from the repository root. For example:
 
 ```bash
 ~/git/c$ ./bin/run-tests
@@ -52,7 +128,7 @@ Firstly make sure you have the necessary tools installed (such as `indent`, `git
 
 ### What Are the CI Scripts?
 You can see from the [.travis.yml](https://github.com/exercism/c/blob/master/.travis.yml) file that Travis is instructed to run scripts from the [`./bin`](https://github.com/exercism/c/tree/master/bin) directory. 
-The work these scripts perform is descibed as folows:
+The work these scripts perform is described as follows:
 
 - `fetch-configlet` just fetches the `configlet` tool from its [repository](https://github.com/exercism/configlet).
 
@@ -62,32 +138,5 @@ The command for `configlet` used by Travis is [`lint`](https://github.com/exerci
 - `verify-indent` runs `indent` and verifies that it did not result in any file changes. 
 If the check does result in file changes, Travis will output the details and report a failure on the related PR.
 
-- `run-tests` loops through each exercise, prepares the exercise for building and then builds it using `make` and runs `valgrind`. 
+- `run-tests` loops through each exercise, prepares the exercise for building and then builds it using `make`, runs the unit tests and then checks it for memory leaks with `valgrind`.
 If there are build errors, any test fails or there is a memory leak, Travis will output the details and report a failure on the related PR.
-
-## Exercise anatomy
-
-Each exercise should be contained in a directory `c/exercises/<my exercise>` with `<my exercise>` referring to the name of the exercise. 
-The structure of the directory is as follows:
-
-```
-+-- <my exercise>
-    +-- makefile
-    +-- src
-    |   +-- example.c
-    |   +-- example.h | <my exercise>.h
-    +-- test
-        +-- test_<my exercise>.c
-        +-- vendor
-            +-- unity.c
-            +-- unity.h
-            +-- unity_internals.h
-```
-
-* `test` - contains the test file `test_<my exercise>.c` and a `vendor` directory containing the test harness [Unity](http://www.throwtheswitch.org/unity/) from [ThrowTheSwitch](http://www.throwtheswitch.org/#intro-1-section).
-ThrowTheSwitch has a decent guide on [getting started with Unity](http://www.throwtheswitch.org/getting-started-with-unity/) should you desire a tutorial. The layout of the test file is described in the [style guide](https://github.com/exercism/c/blob/master/docs/C_STYLE_GUIDE.md#test-file-layout).
-
-* `src` - contains the example files `example.c` and `example.h`. These are both skipped by the `exercism` CLI when downloading to the client, so it is imperative that you do not reference the names of the files in your code. 
-If you need to provide a header file example that is necessary to run your tests it should be named `<my exercise>.h` instead.
-Please also use [`include`](http://faculty.cs.niu.edu/~mcmahon/CS241/c241man/node90.html) guards in your header files. 
-The tests can be run using the [`bin/run-tests`](https://github.com/exercism/c/blob/master/bin/run-tests) script which will rename the `example.{c|h}` files accordingly.

data/tracks/c/exercises/phone-number/test/test_phone_number.c

@@ -2,39 +2,36 @@
 #include "../src/phone_number.h"
 #include <stdlib.h>
 
+char *result;
+
 void setUp(void)
 {
 }
 
 void tearDown(void)
 {
-}
-
-void test_phone_number_clean(const char *input, const char *expected)
-{
-   char *result = phone_number_clean(input);
-
-   TEST_ASSERT_EQUAL_STRING(expected, result);
-
    free(result);
 }
 
 void test_cleans_parens_dashes_and_spaces_from_the_number(void)
 {
-   TEST_IGNORE();               // delete this line to run test
    const char input[] = "(123) 456-7890";
    const char expected[] = "1234567890";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_cleans_numbers_with_dots(void)
 {
-   TEST_IGNORE();
+   TEST_IGNORE();               // delete this line to run test
    const char input[] = "123.456.7890";
    const char expected[] = "1234567890";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_cleans_numbers_with_multiple_spaces(void)
@@ -43,7 +40,9 @@ void test_cleans_numbers_with_multiple_spaces(void)
    const char input[] = "123 456   7890  ";
    const char expected[] = "1234567890";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_invalid_when_9_digits(void)
@@ -52,7 +51,9 @@ void test_invalid_when_9_digits(void)
    const char input[] = "123456789";
    const char expected[] = "0000000000";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_valid_when_11_digits_and_first_digit_is_1(void)
@@ -61,7 +62,9 @@ void test_valid_when_11_digits_and_first_digit_is_1(void)
    const char input[] = "11234567890";
    const char expected[] = "1234567890";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_invalid_when_11_digits_and_first_digit_not_1(void)
@@ -70,7 +73,9 @@ void test_invalid_when_11_digits_and_first_digit_not_1(void)
    const char input[] = "21234567890";
    const char expected[] = "0000000000";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_invalid_when_more_than_11_digits(void)
@@ -79,7 +84,9 @@ void test_invalid_when_more_than_11_digits(void)
    const char input[] = "121234567890";
    const char expected[] = "0000000000";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_invalid_with_letters(void)
@@ -88,7 +95,9 @@ void test_invalid_with_letters(void)
    const char input[] = "123-abc-7890";
    const char expected[] = "0000000000";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_invalid_with_punctuations(void)
@@ -97,7 +106,9 @@ void test_invalid_with_punctuations(void)
    const char input[] = "123-@:!-7890";
    const char expected[] = "0000000000";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_invalid_with_right_number_of_digits_but_letters_mixed_in(void)
@@ -106,7 +117,9 @@ void test_invalid_with_right_number_of_digits_but_letters_mixed_in(void)
    const char input[] = "1a2b3c4d5e6f7g8h9i0j";
    const char expected[] = "0000000000";
 
-   test_phone_number_clean(input, expected);
+   result = phone_number_clean(input);
+
+   TEST_ASSERT_EQUAL_STRING(expected, result);
 }
 
 void test_returns_area_code(void)
@@ -114,13 +127,10 @@ void test_returns_area_code(void)
    TEST_IGNORE();
    const char input[] = "5024567890";
    const char expected[] = "502";
-   char *result;
 
    result = phone_number_get_area_code(input);
 
    TEST_ASSERT_EQUAL_STRING(expected, result);
-
-   free(result);
 }
 
 void test_formats_a_number(void)
@@ -128,13 +138,10 @@ void test_formats_a_number(void)
    TEST_IGNORE();
    const char input[] = "1234567890";
    const char expected[] = "(123) 456-7890";
-   char *result;
 
    result = phone_number_format(input);
 
    TEST_ASSERT_EQUAL_STRING(expected, result);
-
-   free(result);
 }
 
 void test_cleans_number_before_formatting(void)
@@ -142,13 +149,10 @@ void test_cleans_number_before_formatting(void)
    TEST_IGNORE();
    const char input[] = "123-456-7890";
    const char expected[] = "(123) 456-7890";
-   char *result;
 
    result = phone_number_format(input);
 
    TEST_ASSERT_EQUAL_STRING(expected, result);
-
-   free(result);
 }
 
 int main(void)

data/tracks/c/exercises/triangle/src/example.c

@@ -1,30 +1,30 @@
 #include "triangle.h"
 
-bool triangle_equality(triangle_t * input)
+bool triangle_equality(triangle_t input)
 {
-   return (input->a < (input->b + input->c)
-           && input->b < (input->a + input->c)
-           && input->c < (input->a + input->b)
+   return (input.a < (input.b + input.c)
+           && input.b < (input.a + input.c)
+           && input.c < (input.a + input.b)
        );
 }
 
-bool is_equilateral(triangle_t * input)
+bool is_equilateral(triangle_t input)
 {
    return (triangle_equality(input)
-           && (input->a == input->b)
-           && (input->b == input->c)
+           && (input.a == input.b)
+           && (input.b == input.c)
        );
 }
 
-bool is_isosceles(triangle_t * input)
+bool is_isosceles(triangle_t input)
 {
-   return (triangle_equality(input) && ((input->a == input->b)
-                                        || (input->b == input->c)
-                                        || (input->a == input->c))
+   return (triangle_equality(input) && ((input.a == input.b)
+                                        || (input.b == input.c)
+                                        || (input.a == input.c))
        );
 }
 
-bool is_scalene(triangle_t * input)
+bool is_scalene(triangle_t input)
 {
    return (!(is_equilateral(input))
            && !(is_isosceles(input))

data/tracks/c/exercises/triangle/src/example.h

@@ -8,8 +8,8 @@ typedef struct {
    double c;
 } triangle_t;
 
-bool is_equilateral(triangle_t * input);
-bool is_isosceles(triangle_t * input);
-bool is_scalene(triangle_t * input);
+bool is_equilateral(triangle_t input);
+bool is_isosceles(triangle_t input);
+bool is_scalene(triangle_t input);
 
 #endif

data/tracks/c/exercises/triangle/test/test_triangle.c

@@ -12,112 +12,112 @@ void tearDown(void)
 void test_equilateral_is_true_if_all_sides_are_equal(void)
 {
    triangle_t sides = { 2, 2, 2 };
-   TEST_ASSERT_TRUE(is_equilateral(&sides));
+   TEST_ASSERT_TRUE(is_equilateral(sides));
 }
 
 void test_equilateral_is_false_if_any_side_is_unequal(void)
 {
    TEST_IGNORE();               // delete this line to run test
    triangle_t sides = { 2, 3, 2 };
-   TEST_ASSERT_FALSE(is_equilateral(&sides));
+   TEST_ASSERT_FALSE(is_equilateral(sides));
 }
 
 void test_equilateral_is_false_if_all_sides_zero(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 0, 0, 0 };
-   TEST_ASSERT_FALSE(is_equilateral(&sides));
+   TEST_ASSERT_FALSE(is_equilateral(sides));
 }
 
 void test_equilateral_sides_may_be_floats(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 0.5, 0.5, 0.5 };
-   TEST_ASSERT_TRUE(is_equilateral(&sides));
+   TEST_ASSERT_TRUE(is_equilateral(sides));
 }
 
 void test_isosceles_is_true_if_last_two_sides_are_equal(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 3, 4, 4 };
-   TEST_ASSERT_TRUE(is_isosceles(&sides));
+   TEST_ASSERT_TRUE(is_isosceles(sides));
 }
 
 void test_isosceles_is_true_if_first_two_sides_are_equal(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 4, 4, 3 };
-   TEST_ASSERT_TRUE(is_isosceles(&sides));
+   TEST_ASSERT_TRUE(is_isosceles(sides));
 }
 
 void test_isosceles_is_true_if_first_and_last_sides_are_equal(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 4, 3, 4 };
-   TEST_ASSERT_TRUE(is_isosceles(&sides));
+   TEST_ASSERT_TRUE(is_isosceles(sides));
 }
 
 void test_equilateral_triangles_are_also_isosceles(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 4, 4, 4 };
-   TEST_ASSERT_TRUE(is_isosceles(&sides));
+   TEST_ASSERT_TRUE(is_isosceles(sides));
 }
 
 void test_isosceles_is_false_if_no_sides_are_equal(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 2, 3, 4 };
-   TEST_ASSERT_FALSE(is_isosceles(&sides));
+   TEST_ASSERT_FALSE(is_isosceles(sides));
 }
 
 void test_isosceles_is_false_if_two_sides_equal_and_violate_inequality(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 1, 1, 3 };
-   TEST_ASSERT_FALSE(is_isosceles(&sides));
+   TEST_ASSERT_FALSE(is_isosceles(sides));
 }
 
 void test_isosceles_sides_may_be_floats(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 0.5, 0.4, 0.5 };
-   TEST_ASSERT_TRUE(is_isosceles(&sides));
+   TEST_ASSERT_TRUE(is_isosceles(sides));
 }
 
 void test_scalene_is_true_if_no_sides_are_equal(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 5, 4, 6 };
-   TEST_ASSERT_TRUE(is_scalene(&sides));
+   TEST_ASSERT_TRUE(is_scalene(sides));
 }
 
 void test_scalene_is_false_if_all_sides_are_equal(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 4, 4, 4 };
-   TEST_ASSERT_FALSE(is_scalene(&sides));
+   TEST_ASSERT_FALSE(is_scalene(sides));
 }
 
 void test_scalene_is_false_if_two_sides_are_equal(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 4, 4, 3 };
-   TEST_ASSERT_FALSE(is_scalene(&sides));
+   TEST_ASSERT_FALSE(is_scalene(sides));
 }
 
 void test_scalene_is_false_if_no_sides_equal_and_violate_inequality(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 7, 3, 2 };
-   TEST_ASSERT_FALSE(is_scalene(&sides));
+   TEST_ASSERT_FALSE(is_scalene(sides));
 }
 
 void test_scalene_sides_may_be_floats(void)
 {
    TEST_IGNORE();
    triangle_t sides = { 0.5, 0.4, 0.6 };
-   TEST_ASSERT_TRUE(is_scalene(&sides));
+   TEST_ASSERT_TRUE(is_scalene(sides));
 }
 
 int main(void)