
Computer Networking: A Top-Down Approach (7th Edition)
7th Edition
ISBN: 9780133594140
Author: James Kurose, Keith Ross
Publisher: PEARSON
expand_more
expand_more
format_list_bulleted
Question
![# Basic Path Testing: Generating Test Cases
## Objective:
Generate test cases for the following code using Basic Path Testing.
### Code to Analyze:
```cpp
void sort(int a[], int N)
{
int i, j, p, t;
for(i = 0; i < N - 1; i++)
{
p = i;
for(j = i + 1; j < N; j++)
if(a[j] > a[p])
p = j;
if(p != i)
{
t = a[p];
a[p] = a[i];
a[i] = t;
}
}
}
```
### Tasks:
a) **Draw CFG (Control Flow Graph):**
- Create a visual representation of the control flow for the given code.
b) **How many basic paths are there for the CFG?**
- Calculate the number of basic paths based on the control flow graph, using techniques such as cyclomatic complexity.
c) **List the basic paths:**
- Identify the independent paths that form the basis for path coverage.
d) **Generate test cases from it:**
- Develop test cases that cover each identified path to ensure thorough testing of the code.
### Code Explanation:
- The function `sort` takes an array `a` and its size `N`.
- It uses a nested loop to find the maximum element in the unsorted part of the array and swaps it with the first element of the unsorted part.
- The goal is to sort the array in descending order using a selection sort algorithm.
### Conceptual Understanding:
- **Basic Path Testing** involves analyzing the logical paths through a program's code structure.
- **Control Flow Graph (CFG)** is a representation that depicts the control flow of a program using nodes and edges.
- **Cyclomatic Complexity** is calculated to determine the number of linearly independent paths and is used to estimate the number of test cases needed.
By following these steps, an accurate and comprehensive set of test cases can be generated to validate the functionality and correctness of the `sort` function.](https://content.bartleby.com/qna-images/question/ce5cea56-9cd3-471d-b739-11e3ad279d5e/f9d7b8b2-2fd4-40d2-8c54-eebac7bc67b2/vufxn1n_thumbnail.jpeg)
Transcribed Image Text:# Basic Path Testing: Generating Test Cases
## Objective:
Generate test cases for the following code using Basic Path Testing.
### Code to Analyze:
```cpp
void sort(int a[], int N)
{
int i, j, p, t;
for(i = 0; i < N - 1; i++)
{
p = i;
for(j = i + 1; j < N; j++)
if(a[j] > a[p])
p = j;
if(p != i)
{
t = a[p];
a[p] = a[i];
a[i] = t;
}
}
}
```
### Tasks:
a) **Draw CFG (Control Flow Graph):**
- Create a visual representation of the control flow for the given code.
b) **How many basic paths are there for the CFG?**
- Calculate the number of basic paths based on the control flow graph, using techniques such as cyclomatic complexity.
c) **List the basic paths:**
- Identify the independent paths that form the basis for path coverage.
d) **Generate test cases from it:**
- Develop test cases that cover each identified path to ensure thorough testing of the code.
### Code Explanation:
- The function `sort` takes an array `a` and its size `N`.
- It uses a nested loop to find the maximum element in the unsorted part of the array and swaps it with the first element of the unsorted part.
- The goal is to sort the array in descending order using a selection sort algorithm.
### Conceptual Understanding:
- **Basic Path Testing** involves analyzing the logical paths through a program's code structure.
- **Control Flow Graph (CFG)** is a representation that depicts the control flow of a program using nodes and edges.
- **Cyclomatic Complexity** is calculated to determine the number of linearly independent paths and is used to estimate the number of test cases needed.
By following these steps, an accurate and comprehensive set of test cases can be generated to validate the functionality and correctness of the `sort` function.
Expert Solution

arrow_forward
Step 1
Ans:The below diagram shows that flow chart of a program
There are 11 blocks. The entry block and exit block is not given in the diagram above as they are optional. Entry block is basically a START block before 1st block of the CFG and Exit block is basically an END block at which all the blocks without an outward edge terminates. Here blocks 3, 10 and 11 culminates at Exit block.
Below is the flow diagram (CFG).
Step by stepSolved in 2 steps with 2 images

Knowledge Booster
Similar questions
- write the following usong for loopsarrow_forwardJAVA The following code for InsertionSort is given to us by the textbook. Trace the code stepby step using the array[55, 22, 77, 99, 66, 33, 11]on a piece of paper or using a Word document. If the code has errors, correct it and make itwork.public static void insertionSort(double[] list) {for (int i = 1; i < list.length; i++) {/** insert list[i] into a sorted sublist list[0..i-1] so thatlist[0..i] is sorted. */double currentElement = list[i];int k;for (k = i - 1; k >= 0 && list[k] > currentElement; k--) {list[k + 1] = list[k];}// Insert the current element into list[k+1]list[k + 1] = currentElement;}}arrow_forwardvoid func(vector<string>& names){ sort(names.begin(), names.end()); //(a) for(int i = names.size() - 1; i > 0; --i){. //(b) if(names[i] == names[i - 1]){ names[i] = move(names.back()); names.pop_back(); } } } What are the reasons or consequences for the programmer’s choice to loop backwards in the line marked (b), and under what circumstances would the algorithm behave differently if that line were replaced with: for (int i = 1; i < names.size(); ++i) ? What would change?arrow_forward
- int arr[] = {-2, -4, 8, 4, 3, 3, -9};In Java with this given this array, how would this version of Divide and Conqueror be implemented in this case, specifically?arrow_forwardQ5. Find the time complexity of the following code int b = 0; for (j = 0; jj; i--) { b=b+j+i;arrow_forwardCode in Python:arrow_forward
arrow_back_ios
arrow_forward_ios
Recommended textbooks for you
- Computer Networking: A Top-Down Approach (7th Edi...Computer EngineeringISBN:9780133594140Author:James Kurose, Keith RossPublisher:PEARSONComputer Organization and Design MIPS Edition, Fi...Computer EngineeringISBN:9780124077263Author:David A. Patterson, John L. HennessyPublisher:Elsevier ScienceNetwork+ Guide to Networks (MindTap Course List)Computer EngineeringISBN:9781337569330Author:Jill West, Tamara Dean, Jean AndrewsPublisher:Cengage Learning
- Concepts of Database ManagementComputer EngineeringISBN:9781337093422Author:Joy L. Starks, Philip J. Pratt, Mary Z. LastPublisher:Cengage LearningPrelude to ProgrammingComputer EngineeringISBN:9780133750423Author:VENIT, StewartPublisher:Pearson EducationSc Business Data Communications and Networking, T...Computer EngineeringISBN:9781119368830Author:FITZGERALDPublisher:WILEY

Computer Networking: A Top-Down Approach (7th Edi...
Computer Engineering
ISBN:9780133594140
Author:James Kurose, Keith Ross
Publisher:PEARSON

Computer Organization and Design MIPS Edition, Fi...
Computer Engineering
ISBN:9780124077263
Author:David A. Patterson, John L. Hennessy
Publisher:Elsevier Science

Network+ Guide to Networks (MindTap Course List)
Computer Engineering
ISBN:9781337569330
Author:Jill West, Tamara Dean, Jean Andrews
Publisher:Cengage Learning

Concepts of Database Management
Computer Engineering
ISBN:9781337093422
Author:Joy L. Starks, Philip J. Pratt, Mary Z. Last
Publisher:Cengage Learning

Prelude to Programming
Computer Engineering
ISBN:9780133750423
Author:VENIT, Stewart
Publisher:Pearson Education

Sc Business Data Communications and Networking, T...
Computer Engineering
ISBN:9781119368830
Author:FITZGERALD
Publisher:WILEY