Related Articles

# Test Case Generation | Set 3 (Unweighted and Weighted Trees)

• Difficulty Level : Easy
• Last Updated : 27 Sep, 2018

Generating Random Unweighted Trees

• Since this is a tree,  the test data generation plan is such that no cycle gets formed.
• The number of edges is one less than the number of vertices
• For each RUN we first print the number of vertices – NUM first in a new separate line and the next NUM-1 lines are of the form (a b) where a is the parent of b
 `// A C++ Program to generate test cases for``// an unweighted tree``#include``using` `namespace` `std;`` ` `// Define the number of runs for the test data``// generated``#define RUN 5`` ` `// Define the maximum number of nodes of the tree``#define MAXNODE 20`` ` `class` `Tree``{``    ``int` `V;    ``// No. of vertices`` ` `    ``// Pointer to an array containing adjacency listss``    ``list<``int``> *adj;`` ` `    ``// used by isCyclic()``    ``bool` `isCyclicUtil(``int` `v, ``bool` `visited[], ``bool` `*rs);``public``:``    ``Tree(``int` `V);   ``// Constructor``    ``void` `addEdge(``int` `v, ``int` `w);   ``// adds an edge``    ``void` `removeEdge(``int` `v, ``int` `w);   ``// removes an edge`` ` `    ``// returns true if there is a cycle in this graph``    ``bool` `isCyclic();``};`` ` `// Constructor``Tree::Tree(``int` `V)``{``    ``this``->V = V;``    ``adj = ``new` `list<``int``>[V];``}`` ` `void` `Tree::addEdge(``int` `v, ``int` `w)``{``    ``adj[v].push_back(w); ``// Add w to v’s list.``}`` ` `void` `Tree::removeEdge(``int` `v, ``int` `w)``{``    ``list<``int``>::iterator it;``    ``for` `(it=adj[v].begin(); it!=adj[v].end(); it++)``    ``{``        ``if` `(*it == w)``        ``{``            ``adj[v].erase(it);``            ``break``;``        ``}``    ``}``    ``return``;``}`` ` `// This function is a variation of DFSUytil() in``// https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/``bool` `Tree::isCyclicUtil(``int` `v, ``bool` `visited[], ``bool` `*recStack)``{``    ``if` `(visited[v] == ``false``)``    ``{``        ``// Mark the current node as visited and part of``        ``// recursion stack``        ``visited[v] = ``true``;``        ``recStack[v] = ``true``;`` ` `        ``// Recur for all the vertices adjacent to this vertex``        ``list<``int``>::iterator i;``        ``for` `(i = adj[v].begin(); i != adj[v].end(); ++i)``        ``{``            ``if` `(!visited[*i] && isCyclicUtil(*i, visited, recStack))``                ``return` `true``;``            ``else` `if` `(recStack[*i])``                ``return` `true``;``        ``}`` ` `    ``}``    ``recStack[v] = ``false``;  ``// remove the vertex from recursion stack``    ``return` `false``;``}`` ` `// Returns true if the graph contains a cycle, else false.``// This function is a variation of DFS() in``// https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/``bool` `Tree::isCyclic()``{``    ``// Mark all the vertices as not visited and not part of recursion``    ``// stack``    ``bool` `*visited = ``new` `bool``[V];``    ``bool` `*recStack = ``new` `bool``[V];``    ``for``(``int` `i = 0; i < V; i++)``    ``{``        ``visited[i] = ``false``;``        ``recStack[i] = ``false``;``    ``}`` ` `    ``// Call the recursive helper function to detect cycle in different``    ``// DFS trees``    ``for` `(``int` `i = 0; i < V; i++)``        ``if` `(isCyclicUtil(i, visited, recStack))``            ``return` `true``;`` ` `    ``return` `false``;``}`` ` `int` `main()``{``    ``set> container;``    ``set>::iterator it;`` ` `    ``// Uncomment the below line to store``    ``// the test data in a file``    ``// freopen ("Test_Cases_Unweighted_Tree.in", "w", stdout);`` ` `    ``//For random values every time``    ``srand``(``time``(NULL));`` ` `    ``int` `NUM;    ``// Number of Vertices/Nodes`` ` `    ``for` `(``int` `i=1; i<=RUN; i++)``    ``{``        ``NUM = 1 + ``rand``() % MAXNODE;`` ` `        ``// First print the number of vertices/nodes``        ``printf``(``"%d\n"``, NUM);``        ``Tree t(NUM);``        ``// Then print the edges of the form (a b)``        ``// where 'a' is parent of 'b'``        ``for` `(``int` `j=1; j<=NUM-1; j++)``        ``{``            ``int` `a = ``rand``() % NUM;``            ``int` `b = ``rand``() % NUM;``            ``pair<``int``, ``int``> p = make_pair(a, b);`` ` `            ``t.addEdge(a, b);`` ` `            ``// Search for a random "new" edge everytime``            ``while` `(container.find(p) != container.end()``                    ``|| t.isCyclic() == ``true``)``            ``{``                ``t.removeEdge(a, b);`` ` `                ``a = ``rand``() % NUM;``                ``b = ``rand``() % NUM;``                ``p = make_pair(a, b);``                ``t.addEdge(a, b);``            ``}``            ``container.insert(p);``        ``}`` ` `        ``for` `(it=container.begin(); it!=container.end(); ++it)``            ``printf``(``"%d %d\n"``, it->first, it->second);`` ` `        ``container.clear();``        ``printf``(``"\n"``);``    ``}`` ` `    ``// Uncomment the below line to store``    ``// the test data in a file``    ``// fclose(stdout);``    ``return``(0);``}`

Generating Random Weighted Trees

• Since this is a tree,  the test data generation plan is such that no cycle gets formed.
• The number of edges is one less than the number of vertices
• For each RUN we first print the number of vertices – NUM first in a new separate line and the next NUM-1 lines are of the form (a b wt) where a is the parent of b and the edge has a weight of wt
 `// A C++ Program to generate test cases for``// an unweighted tree``#include``using` `namespace` `std;`` ` `// Define the number of runs for the test data``// generated``#define RUN 5`` ` `// Define the maximum number of nodes of the tree``#define MAXNODE 20`` ` `// Define the maximum weight of edges``#define MAXWEIGHT 200`` ` `class` `Tree``{``    ``int` `V;    ``// No. of vertices`` ` `    ``// Pointer to an array containing adjacency lists``    ``list<``int``> *adj;`` ` `    ``// used by isCyclic()``    ``bool` `isCyclicUtil(``int` `v, ``bool` `visited[], ``bool` `*rs);``public``:``    ``Tree(``int` `V);   ``// Constructor``    ``void` `addEdge(``int` `v, ``int` `w);   ``// adds an edge``    ``void` `removeEdge(``int` `v, ``int` `w); ``// removes an edge`` ` `    ``// returns true if there is a cycle in this graph``    ``bool` `isCyclic();``};`` ` `Tree::Tree(``int` `V)``{``    ``this``->V = V;``    ``adj = ``new` `list<``int``>[V];``}`` ` `void` `Tree::addEdge(``int` `v, ``int` `w)``{``    ``adj[v].push_back(w); ``// Add w to v’s list.``}`` ` `void` `Tree::removeEdge(``int` `v, ``int` `w)``{``    ``list<``int``>::iterator it;``    ``for` `(it=adj[v].begin(); it!=adj[v].end(); it++)``    ``{``        ``if` `(*it == w)``        ``{``            ``adj[v].erase(it);``            ``break``;``        ``}``    ``}``    ``return``;``}`` ` `// This function is a variation of DFSUytil() in``// https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/``bool` `Tree::isCyclicUtil(``int` `v, ``bool` `visited[], ``bool` `*recStack)``{``    ``if``(visited[v] == ``false``)``    ``{``        ``// Mark the current node as visited and part of``        ``// recursion stack``        ``visited[v] = ``true``;``        ``recStack[v] = ``true``;`` ` `        ``// Recur for all the vertices adjacent to this vertex``        ``list<``int``>::iterator i;``        ``for` `(i = adj[v].begin(); i != adj[v].end(); ++i)``        ``{``            ``if` `(!visited[*i] && isCyclicUtil(*i, visited,``                                            ``recStack))``                ``return` `true``;``            ``else` `if` `(recStack[*i])``                ``return` `true``;``        ``}`` ` `    ``}`` ` `     ``// remove the vertex from recursion stack``    ``recStack[v] = ``false``;`` ` `    ``return` `false``;``}`` ` `// Returns true if the graph contains a cycle, else false.``// This function is a variation of DFS() in``// https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/``bool` `Tree::isCyclic()``{``    ``// Mark all the vertices as not visited and not part``    ``// of recursion stack``    ``bool` `*visited = ``new` `bool``[V];``    ``bool` `*recStack = ``new` `bool``[V];``    ``for` `(``int` `i = 0; i < V; i++)``    ``{``        ``visited[i] = ``false``;``        ``recStack[i] = ``false``;``    ``}`` ` `    ``// Call the recursive helper function to detect cycle``    ``// in different DFS trees``    ``for` `(``int` `i = 0; i < V; i++)``        ``if` `(isCyclicUtil(i, visited, recStack))``            ``return` `true``;`` ` `    ``return` `false``;``}`` ` `int` `main()``{``    ``set > container;``    ``set >::iterator it;`` ` `    ``// Uncomment the below line to store``    ``// the test data in a file``    ``// freopen ("Test_Cases_Weighted_Tree1.in", "w", stdout);`` ` `    ``//For random values every time``    ``srand``(``time``(NULL));`` ` `    ``int` `NUM;    ``// Number of Vertices/Nodes`` ` `    ``for` `(``int` `i=1; i<=RUN; i++)``    ``{``        ``NUM = 1 + ``rand``() % MAXNODE;`` ` `        ``// First print the number of vertices/nodes``        ``printf``(``"%d\n"``, NUM);``        ``Tree t(NUM);`` ` `        ``// Then print the edges of the form (a b wt)``        ``// where 'a' is parent of 'b' and the edge has``        ``// a weight of 'wt'``        ``for` `(``int` `j=1; j<=NUM-1; j++)``        ``{``            ``int` `a = ``rand``() % NUM;``            ``int` `b = ``rand``() % NUM;``            ``pair<``int``, ``int``> p = make_pair(a, b);`` ` `            ``t.addEdge(a, b);`` ` `            ``// Search for a random "new" edge everytime``            ``while` `(container.find(p) != container.end()``                    ``|| t.isCyclic() == ``true``)``            ``{``                ``t.removeEdge(a, b);`` ` `                ``a = ``rand``() % NUM;``                ``b = ``rand``() % NUM;``                ``p = make_pair(a, b);``                ``t.addEdge(a, b);``            ``}``            ``container.insert(p);``        ``}`` ` `        ``for` `(it=container.begin(); it!=container.end(); ++it)``        ``{``            ``int` `wt = 1 + ``rand``() % MAXWEIGHT;``            ``printf``(``"%d %d %d\n"``, it->first, it->second, wt);``        ``}`` ` `        ``container.clear();``        ``printf``(``"\n"``);``    ``}`` ` `    ``// Uncomment the below line to store``    ``// the test data in a file``    ``// fclose(stdout);``    ``return``(0);``}`

This article is contributed by Rachit Belwariar. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.