[Pick the date] | Class | Instructor’s Name What Is Autism? [Your Name]What Is Autism?       Insert text here Second Story Headline 3 What is the history of autism?       Insert text here       Insert text here How has autism changed over the years?      Insert text here How is Autism diagnosed? How is autism diagnosed?       Insert text here Family Supports and Resources       Insert text here Second Story Headline � 1 A brief overview of Autism Spectrum Disorders (ASD) Contents What is autism? 1 What is the history of autism? 2 How has autism changed over the years? 3 How is autism diagnosed? 4 References 6 2 � Replace this text with a quote from the document or a summary of an interesting point. You can position the text box anywhere in the document. � PAGE \* MERGEFORMAT �3� Inside Story Headline Add a highlight here. � � 4 � 5 6 References PA301 – Simple Translation Dictionary We want to implement a program which will help students learn the vocabulary of foreign languages. The first step, which has been assigned to you, is to build a data structure representing a list of English words and their translation in a foreign language. We’ll also need to provide functions allowing us to lookup translations from English-to- Foreign and Foreign-to-English. The main data structure of this program encapsulates some variables specifying the maximal and current number of words in the dictionary along with a pointer to a dynamically allocated array of pointers on another data structure representing a pair of words. A skeleton for this project is provided to you along with the struct definitions. Files you will be working with You will be provided with several files to get you started working on this assignment. - You must not alter the file names, remove or add files to the project - You must only modify the ones marked below with a yes in “Modify it?” - You must not insert any comments or code in the tests.c file which, when read by another student, would give them any insights about the solutions you implemented in tools.c. Important Academic Honesty Note; The role of tests.c is to allow you to test your program to verify it adheres to requirements. Your instructor might allow you to exchange this file, and this file only, with other students. Therefore, you must uphold academic honesty standards by not inserting any information, besides the tests, which would divulge your design or implementation of the solutions to another student. Failure to do so will earn you a FF for the offering. Here are the files; File name Modify it? Role tools.c Yes Implementation of your solution to the assignment tests.c Yes Implementation of your test functions tools.h No Header file for tools.c main.c No Implementation of the main function starting your.

1. [Pick the date] | Class | Instructor’s Name
What Is Autism?
[Your Name]What Is Autism?
Insert text here
Second Story Headline
3
What is the history of autism?
Insert text here
Insert text here
How has autism changed over the years?
Insert text here
How is Autism diagnosed?
How is autism diagnosed?
Insert text here
Family Supports and Resources
Insert text here

2. Second Story Headline
�
1
A brief overview of Autism Spectrum Disorders (ASD)
Contents
What is autism? 1
What is the history of autism? 2
How has autism changed over the years? 3
How is autism diagnosed? 4
References 6

3. 2
�
Replace this text with a quote from the document or a summary
of an interesting point. You can position the text box anywhere
in the document.
� PAGE * MERGEFORMAT �3�
Inside Story Headline
Add a highlight here.
�
�

4. 4
�
5
6
References
PA301 – Simple Translation Dictionary
We want to implement a program which will help students learn
the vocabulary of
foreign languages. The first step, which has been assigned to
you, is to build a data
structure representing a list of English words and their

5. translation in a foreign language.
We’ll also need to provide functions allowing us to lookup
translations from English-to-
Foreign and Foreign-to-English. The main data structure of this
program encapsulates
some variables specifying the maximal and current number of
words in the dictionary
along with a pointer to a dynamically allocated array of pointers
on another data structure
representing a pair of words.
A skeleton for this project is provided to you along with the
struct definitions.
Files you will be working with
You will be provided with several files to get you started
working on this assignment.
- You must not alter the file names, remove or add files to the
project
- You must only modify the ones marked below with a yes in
“Modify it?”
- You must not insert any comments or code in the tests.c file
which, when read by
another student, would give them any insights about the
solutions you

6. implemented in tools.c.
Important Academic Honesty Note;
The role of tests.c is to allow you to test your program to verify
it adheres to
requirements. Your instructor might allow you to exchange this
file, and this file
only, with other students. Therefore, you must uphold academic
honesty standards
by not inserting any information, besides the tests, which would
divulge your
design or implementation of the solutions to another student.
Failure to do so will
earn you a FF for the offering.
Here are the files;
File name Modify it? Role
tools.c Yes Implementation of your solution to the assignment
tests.c Yes Implementation of your test functions
tools.h No Header file for tools.c
main.c No Implementation of the main function starting your
tests
testlib.h No Definition of the TEST function you must use in

7. your tests
testlib.c No Implementation of the above
Task #1 – Implement and test dictionary_build
This first function, which you will implement in tools.c, will be
used every time you
need to start working on a new dictionary. Part of your grade on
this implementation will
be on how well your function handles error situations; e.g. we
ask for a dictionary of
negative size, there is no memory available for your malloc…
Any time you encounter one of these, or similar, errors, you
should return a specific
value from your function which is described in the program’s
source itself. When you test
your function with such parameters, you should verify its return
value is appropriate.
Make sure you follow our usual process when working on this
function;
- Read the requirements & existing source thoroughly
- Implement your tests based on how you understand the

8. requirements. This time you
will note that we are not providing tests at all. Part of your
work is to leverage what
you learned in the previous PAs to design & implement your
own tests
- Implement the function dictionary_build
- Update your tests based on what you learned
- Refactor your solution before to go to the next task.
Task #2 – Implement and test dictionary_free
This 2nd function will be used to de-allocate a dictionary. Here
are some things to keep
in mind;
- Make sure you dispose of all the memory you allocated in a
struct dictionary.
Drawing a diagram of the data structures will help you figure
out what you are de-
allocating as you write your dictionary_free function. This
should help you avoid
memory leaks.
- If the dictionary passed to your function is only partially
allocated – e.g. due to a
bug elsewhere – you should handle it gracefully; i.e. before to

9. free a pointer, make
sure it is not NULL.
Follow the steps outlined in task#1 as you work on
implementing this task. Again, the
source code provides you with most of the information you need
in the form of comments
and the code itself.
Task #3 – Implement and test dictionary_add
The 3rd function will take a dictionary and two strings as
parameters. It will use strdup
to make a copy of the words provided as parameters and insert
them as a new element in
the dictionary.
Again, detect possible bad parameters; e.g. no words provided;
1 word instead of 2…
and verify the return value is appropriate based on the
documentation in the program
itself.
Follow the steps outlined in task#1 as you work on
implementing this task.
Task #4 – Implement and test dictionary_translate

10. This function, as indicated in its comments, will return a strdup
copy of the translation
of one of the two strings passed as parameter. It is expected that
one will use this function
with a valid dictionary, and specify one of the two strings to be
NULL.
- If the English word parameter is NULL, we are providing a
string in the foreign
language to be translated into English.
- If the foreign word is NULL, we do the opposite.
Passing two non-NULL strings or a NULL dictionary are errors
which should be
handled by your function returning the value described in the
documentation in the
program itself.
Follow the steps outlined in task#1 as you work on
implementing this task.
PA301/main.c
// TODO - Nothing! Do not modify this file
#include <stdio.h>

11. #include <stdlib.h>
#include <string.h>
extern void runAllTests();
int main()
{
printf("Welcome to the Simple Translation
Dictionary!!!nnn");
runAllTests();
return EXIT_SUCCESS;
}
PA301/PA301.cbp
PA301/PA301.depend# depslib dependency file v1.01301965052
source:c:usersalessiodesktopworkbench___pa301main.c<st
dio.h><stdlib.h><string.h>1404255894
source:c:usersalessiodesktopworkbench___pa301tools.c<st
dlib.h><stdio.h><string.h>tools.h1404256047
c:usersalessiodesktopworkbench___pa301tools.h14083930
15

12. source:c:usersalessiolptdesktopworkbench301templatemain
.c<stdio.h><stdlib.h><string.h>1408393835
source:c:usersalessiolptdesktopworkbench301templatetests
.c<stdio.h><stdlib.h>testlib.htools.h1408418401
c:usersalessiolptdesktopworkbench301templatetestlib.h140
4259647
c:usersalessiolptdesktopworkbench301templatetools.h1408
393385
source:c:usersalessiolptdesktopworkbench301templatetools
.c<stdlib.h><stdio.h><string.h>tools.h1408418377
source:c:usersalessiolptdesktopworkbench301templatetestl
ib.c<stdlib.h><stdio.h>testlib.h1408418655
source:c:usersalessiolptdesktopworkbenchongoing
stuff301pa301tests.c<stdio.h><stdlib.h>testlib.htools.h14085
14693 c:usersalessiolptdesktopworkbenchongoing
stuff301pa301testlib.h1404259647
c:usersalessiolptdesktopworkbenchongoing
stuff301pa301tools.h1408393385
source:c:usersalessiolptdesktopworkbenchongoing
stuff301pa301tools.c<stdlib.h><stdio.h><string.h>tools.h
PA301/PA301.layout
PA301/testlib.c
// TODO - nothing, do not modify this file
#include <stdlib.h>
#include <stdio.h>
#include "testlib.h"

13. void TEST(const char * const shortDescription, int boolexp){
// keep track of tests numbers
static int testNumber = 0;
testNumber++;
// string representing the outcome of the test
char* testResult = NULL;
// determining the outcome
if(boolexp){
testResult = "OK";
}else{
testResult = "FAILS";
}
printf("[Test] #%3d --> %-5.5st%-50.50sn", testNumber,
testResult, shortDescription);
fflush(stdout);

14. }
PA301/testlib.h
// TODO - nothing, do not modify this file
#ifndef TESTLIB_H_INCLUDED
#define TESTLIB_H_INCLUDED
void TEST(const char * const shortDescription, int boolexp);
/* ROLE This function display information about the test
being "OK" or "FAILED"
based on whether the condition used as parameter is
respectively true or false
PARAMETERS
shortDescription a string describing the test. 45
characters long maximum
boolexp the result of evaluating a boolean
expression representing
what we are testing. If it evaluates to true,
the function
will display that the test succeeded.
Otherwise, it will

15. display that the test failed.
*/
#endif // TESTLIB_H_INCLUDED
PA301/tests.c
// TODO - Implement your tests in this file using testlib
functions
#include <stdio.h>
#include <stdlib.h>
#include "testlib.h"
#include "tools.h"
void test_example(){
// Example test function for you to adapt
struct dictionary * d = NULL;
d = dictionary_build(-3);

16. TEST("Building with negative size should return NULL",
d==NULL);
}
void runAllTests(){
/* ROLE Runs all the tests specified and displays results
*/
// For instance, you would have the following line in our
example;
// test_example();
}
PA301/tools.c
// TODO - Implement the functions in this file
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

17. #include "tools.h"
struct dictionary *dictionary_build(int size){
return NULL;
}
int dictionary_add(struct dictionary* d,
const char * const english,
const char * const foreign){
return -1;
}
int dictionary_free( struct dictionary ** p){
return -1;
}
char* dictionary_translate( struct dictionary* d,
const char* const english_word,

18. const char* const foreign_word){
return NULL;
}
PA301/tools.h
// TODO - nothing, do not modify this file
#ifndef _TOOLS_H_
#define _TOOLS_H_
/* Data Structures Definitions */
struct wordPair {
char* englishWord;
char* foreignWord;
};
struct dictionary {
struct wordPair ** data;

19. int nbwords;
int size;
};
/* Prototypes of functions */
struct dictionary* dictionary_build(int size);
/* ROLE Allocate and initialize a new dictionary
structure able to accommodate
a number of pairs of words specified by the size
parameter
RETURNS Address of new dictionary, if allocation was
successful.
NULL otherwise
PARAMETERS The size of the dictionary to make
*/
int dictionary_add(struct dictionary* d,

20. const char * const english,
const char * const foreign);
/* ROLE Adds a new wordPair made of strdup copies of
the parameter strings
to a dictionary d
RETURNS 0 if everything went fine
-1 if the dictionary or the field inside of it used to
store
word pairs are NULL
-2 if we are unable to allocate a new wordPair
-3 if the English word is missing, i.e. English
parameter is NULL
-4 if the foreign word is missing, i.e. foreign
parameter is NULL
-5 if the dictionary is already full
-6 for any other problem you are able to detect -
if any
PARAMETERS d the dictionary to work with
English string representing the English part of

21. the new wordPair
foreign string representing the foreign part of
the new wordPair
*/
char* dictionary_translate(struct dictionary* d,
const char* const english,
const char* const foreign);
/* ROLE Looks up the dictionary d for the translation
of a word depending on what
parameters are provided.
RETURNS If English is non NULL and foreign is
NULL, return a strdup of the
translation of English in d
if foreign is non NULL and English is NULL,
return a strdup of the
translation of foreign in d
If anything goes wrong, return NULL

22. PARAMETERS d Address of the dictionary to
work with
English string representing the English word to
translate, if any
foreign string representing the foreign work to
translate, if any
REMARKS words are not in any specific order, do not
assume an order when
searching in this "dictionary", you'll have to look
up every entry
against the words you are looking up
*/
int dictionary_free(struct dictionary** p);
/* ROLE Deallocate all memory which has been
dynamically allocated
in the dictionary structure pointed to by *p. Then
set the

23. pointer which address was passed as parameter to
NULL.
RETURNS 0 if everything went fine
-1 if we encountered some NULL pointers
where we should
have encountered non-NULL pointers
PARAMETERS Pointer on a pointer on our dictionary
REMARKS Please note that if a pointer has a wrong
address, we have no way to
detect this. We will just deallocate it and
potentially trigger a bug.
*/
#endif