A triangle can be broadly classified according to the length of its sides and the angle between the sides.
Based on the sides, there are three types of triangle
1. Equilateral Triangle
2. Isosceles Triangle
3. Scalene Triangle

Based on the angles, there are also 3 types:
1. Acute triangle
2. Right triangle
3. Obtuse triangle

In this article, we’ll be discussing triangles that are classified based on sides, and implementing the same in the program.

1. Equilateral Triangle: A triangle in which all sides are of the same length
2. Isosceles Triangle: A triangle in which exactly two sides are equal
3. Scalene Triangle: A triangle in which all sides are having different length

Approach to determine the type of a triangle

1. Read the length of a triangle for the user
2. If side1, side2 and side3 are equal to each other, then
   • print a message the triangle is an equilateral triangle
3.  If any two from side1, side2 or side3 are having the same length, then
   • print message the triangle is isosceles triangle
4.  If all three sides are different in length, then
   • print message the triangle is a scalene triangle

C Program To Check whether Triangle is Equilateral, Isosceles or Scalene

The program also implies Triangle Inequality Theorem to validate whether the given sides can be a triangle or not.

Program:

#include<conio.h>
#include<stdio.h>
#include<math.h>
void
main ()
{
  int a, b, c, flag = -1;
  printf (" Enter the values of a, b and c : = ");
  scanf ("%d %d %d", &a, &b, &c);
  if ((a >= 0 && a <= 10) && (b >= 0 && b <= 10) && (c >= 0 && c <= 10)){
 
 // Triangle Inequality Theorem : every side's length should be shorter than sum of other two side
      if (((a + b) > c) && ((b + c) > a) && ((c + a) > b)){
    flag = 1;
    if ((a == b) && (b == c))
      printf ("\n It is an Equilatral Triangle");
    else if ((a == b) || (b == c) || (c == a))
      printf ("\n It is an isosceles Triangle");
    else
      printf ("\n It is a Scalene Triangle");
      }
    }
    
  if (flag == -1)
    printf ("Given side inputs, can't be a triangle ");
    
  getch ();
}

Testing Result of the Program

Not a Triangle

 Enter the values of a, b and c : = 11 5 5
Given side inputs, can't be a triangle 

Equilateral triangle

Enter the values of a, b and c : = 4 4 4

It is an Equilateral Triangle

Isosceles Triangle

Enter the values of a, b and c : = 2 3 2

It is an isosceles Triangle

Same as path testing make flow graph.

Now, make Decision-to-Decision table in which consecutive nodes are counted as an individual.

On the basis of above table, create DD graph.

After DD graph, it is time to figure out du and dc paths. For this, create ‘ defined node and used at node’ table to view variable’s definition and initialization.

From above table, find du and dc paths.

Based on du and dc paths create test cases, covering each and every variable definition and usage.

Here’s is the triangle problem code.

In path testing, first we create the flow graph of the triangle problem based on the program which shows the flow and possible paths.

Once the flow graph is created, with the help of it list all the consecutive nodes and assign an alphabet to them.

After creating DD Table, it’s time to generate DD graph through which Cyclomatic complexity and the possible path will be gathered.

Using DD graph ( Decision to Decision graph ), calculate the cyclomatic complexity which tells all the independent paths.

Cyclomatic complexity = E – N + 2P

= 20-16+2

=6

Possbile paths are:

-A,B,C,D,E,F,G,K,L,M,O,P
-A,B,C,D,E,F,H,I,K,L,M,O,P
-A,B,C,D,E,F,H,J,K,L,M,O,P
-A,B,C,D,K,L,M,O,P
-A,B,C,D,K,L,M,N,O,P
-A,B,K,L,M,O,P

Based on these paths, we will create Test cases.

If you’re curious to see the “Triangle Problem “ code, then the link is here with tested test cases.

Decision Table Based Testing

In Decision table based testing,  Condition stubs and Action stubs are viewed as inputs and outputs. Here, we’ll be applying this Structural testing technique to create test cases:

Let’s create the decision table first,

On the basis of above decision table, we have these test cases for testing:

In triangle problem, we require to identify output and input domain.

Output Domain:

O₁ = Not a triangle, when any of the sides is greater than the sum of the other
O₂ = Equilateral Triangle
O₃ = Isosceles Triangle
O₄ = Scalene Triangle

Input Domain:
I₁ = { 0< a <= 10 }
I₂ = { a<0 }
I₃ = { a>10 }
I₄ = { 0< b <= 10 }
I₅= { b<0 }
I₆ = { b>10 }
I₇ = { 0< c <= 10 }
I₈ = { c<0 }
I₉ = { c>10 }

Further, on the basis of sides equality and whether the sum of the two sides are equal or greater, we can create classes.
I₁₀ = { a=b=c }
I₁₁ = { a=b, b!=c }
I₁₂ = { b=c, c!=a }
I₁₃ = { a=c, c!=b }
I₁₄ = { a!=b!=c }
I₁₅ = { a+b = c }
I₁₆ = { a+b < c }
I₁₇ = { b+c = a }
I₁₈ = { b+c < a }
I₁₉ = { c+a = b }
I₂₀ = { c+a >b }
There are 4 possible outcomes and 20 possible input classes, in total 24 test cases to test.

Here are the test cases and program tested results.

An isosceles triangle is a triangle in which two sides are equal.

An equilateral triangle is a triangle in which all sides are equal.

A scalene triangle is a triangle in which no two sides are equivalent to one other.

Program:

Here you can find  “Triangle problem” program along with its tested output.

Robustness Testing

We are assuming interval [1,10] for creating test cases and we will generate test cases using Robustness testing accordingly.

In Robustness Testing, 6N+1 test cases will be generated, which means, in this case, 6*3+1 = 19 test cases.

Test ID	a	b	c	Expected Output	Program Output	Tested Outcome
1	0	5	5	Invalid Input	Invalid Input	Pass
2	1	5	5	Isosceles	Isosceles	Pass
3	2	5	5	Isosceles	Isosceles	Pass
4	9	5	5	Isosceles	Isosceles	Pass
5	10	5	5	Not a Triangle	Not a Triangle	Pass
6	11	5	5	Invalid Input	Invalid Input	Pass
7	5	0	5	Invalid Input	Invalid Input	Pass
8	5	1	5	Isosceles	Isosceles	Pass
9	5	2	5	Isosceles	Isosceles	Pass
10	5	9	5	Isosceles	Isosceles	Pass
11	5	10	5	Not a Triangle	Not a Triangle	Pass
12	5	11	5	Invalid Input	Invalid Input	Pass
13	5	5	0	Invalid Input	Invalid Input	Pass
14	5	5	1	Isosceles	Isosceles	Pass
15	5	5	2	Isosceles	Isosceles	Pass
16	5	5	9	Isosceles	Isosceles	Pass
17	5	5	10	Not a Triangle	Not a Triangle	Pass
18	5	5	11	Invalid Input	Invalid Input	Pass
19	5	5	5	Equilateral	Equilateral	Pass

An isosceles triangle is a triangle in which its two sides are equal.

An equilateral triangle is a triangle in which all three sides are equal.

A scalene triangle is a triangle in which no sides are equivalent to one other.

We are supposing interval [1,10] for test cases and will generate test cases using Boundary value analysis accordingly. Expected Output can be [ Scalene Triangle, Not a Triangle, Equilateral triangle, Isosceles Triangle ]

Program:

#include<conio.h>
#include<stdio.h>
void main()
{
  int a,b,c,result;
  printf(" Enter the values of a, b and c : = ");
  scanf("%d %d %d", &a,&b,&c);
    if(((a+b)>c)&&((b+c)>a)&&((c+a)>b))
    {
      
      if((a==b)&&(b==c))
          printf("\n It is an Equilatral Triangle");
    else if((a==b)||(b==c)||(c==a))
        printf("\n It is an isosceles Triangle");
          else
              printf("\n It is a Scalene Triangle");
      
    }
    else
    printf("\n not a triangle");
    
  

  getch();
}

In Boundary Value Analysis, 4N+1  test case will be generated, which means, in this case, 4*3+1 = 13 test cases.

Testing Result of the Program

Not a Triangle

Equilateral triangle

Isosceles Triangle