Author: vibssingh

vibssingh

How to verify JSON response headers in Rest Assured?

HOME

We can verify JSON response headers in Rest Assured. This is achieved with the help of the header method.  Every response obtained from the server may contain zero or more headers that provide metadata about the response.

import org.junit.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.containsString;

public class ResponseHeader {

    @Test
    public void verifyResponseHeader() {

      // Given
      given()

              // When
              .when()
              .get("https://reqres.in/api/users/2")

              // Then
              .then()
              .statusCode(200).statusLine("HTTP/1.1 200 OK")
              .log().all()
              .header("Content-Type" , "application/json; charset=utf-8")
              .header("Content-Encoding" , "gzip")
              .header("Server" , containsString("cloudflare"));

    }
}

The output of the above program is

In the above example, we can verify the Content-Type, Server, and Content-Encoding using the header.

vibssingh

Class and Object in Java

HOME

In this blog, we will discuss Classes and Objects. Java is an Object-Oriented Programming language. Class, Objects, Variables, Methods, and Constructors are the building blocks of Object-Oriented language.

What is a Class?

A class is a user-defined template or prototype that is used to create objects and define object data types and methods.

What is an Object?

An object is an instance of a class. An entity that has state and behaviour.

Let us consider the Phone as the object. The state of the Phone is coloured grey, and black, and types like IPhone, Samsung, and behaviour is calling, sending messages, and internet browsing.

How to create a class?

To create a class, a keyword class is used.

Here, I am creating a class with the name Student with the variable Name.

public class Student {
          String Name;
}

How to create an Object?

To create an object, specify a class name like Student, an object name like stud, and use a new keyword. 

Student stud = new Student();

Let us create a class and an object of its class and print the value of the variable name.

public class Student {

    String Name = "Tom";
    public static void main(String[] args)

    {
        Student stud = new Student();
        System.out.println("Name of Student :"+stud.Name);
    }
}

The output of the above program is

Multiple Objects of a Class

We can create multiple objects of a class. In the below example, we have created 2 objects of class Student.

public class Student {

    String Name = "Tom";
    public static void main(String[] args)
    {
        Student stud1 = new Student();
        Student stud2 = new Student();
        System.out.println("Name of Student :"+stud1.Name);
        System.out.println("Name of Student :"+stud2.Name);
    }
}

The output of the above program is

Multiple Classes

We can create a class and then create an object of that class in another class. Like, here, we have created a class called Student.java and another class is Student_Demo.java where we will create the object of class Student. This is a better approach than the previous one.

public class Student {
          String Name = "Tom";         
}


public class Student_Test{
    public static void main(String[] args)
    {
        Student stud = new Student();
        System.out.println("Name of Student :"+stud.Name);
    }
}

There are multiple ways to initialize the classes and objects.

1) Initialize through reference

Here, initializing an object means storing data in the object. Let’s see a simple example where we are going to initialize the object through a reference variable.

public class Student {
          String Name ;
          int Age;
}

public class Student_Test {
    public static void main(String[] args)
    {
        Student stud = new Student();
        stud.Name ="Tom";
        stud.Age=35;
        System.out.println("Name of Student :"+stud.Name);
        System.out.println("Age of Student :"+stud.Age);
    }
}

The output of the above program is

2) Initializing through method

We are creating the two objects of the Student class and initializing the value to these objects by invoking the InsertData() method. Here, we are displaying the state (data) of the objects by invoking the DisplayData() method.

public class Student {
	String Name;
	int Age;

	void InsertData(String n, int a) {
		Name = n;
		Age = a;
	}

	void DisplayData() {
		System.out.println("Name of Student :" + Name);
		System.out.println("Age of Student :" + Age);
	}
}


public class Student_Test {
    
    public static void main(String[] args) {
        Student stud = new Student();
        stud.InsertData("Tom", 34);
        stud.DisplayData();
    }
}

The output of the above program is

We can create multiple objects

public class Student {
          String Name ;
          int Age;

          void InsertData(String n, int a)
          {
                   Name =n;
                   Age = a;
          }

          void DisplayData()
          {
                   System.out.println("Name of Student :"+Name);
                   System.out.println("Age of Student :"+Age);
          }
    }  


public class Student_Test {
    
    public static void main(String[] args) {

            Student stud1 = new Student();
            Student stud2 = new Student();
            stud1.InsertData("Matt",43);
            stud1.DisplayData();
            stud2.InsertData("Terry",36);
            stud2.DisplayData();
    }
 }

The output of the above program is

We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

Method Overloading in Java

Last Updated On

HOME

What is Method Overloading?

It is a feature that allows a class to have more than one method of the same name, but different parameters. The method can be overloaded if:-

  1. No of parameters are different in two methods
  2. Type of parameters are different
  3. Sequence of parameters are different

Note:- If two methods have same name, same no of parameters, same sequence of parameters and same type of parameters but different return type, then the methods are not overloaded. It will show compile time error.

Why do we need Method Overloading?

If we need to perform the same kind of operation with different data inputs, we go for method overloading. Below is an example of an addition operation with different inputs to explain method overloading. It is an example of static polymorphism early binding or compile time binding. Here, the binding of the method call to its definition happens at compile time.

Below is an example of method overloading.

public class MethodOverloading_Demo {

    public void Calculation(int a, float b) {
        System.out.println("Sum of 2 numbers :" + (a + b));
    }

    //Different type of parameters
    public void Calculation(float x, float y) {
        System.out.println("Sum of 2 numbers :" + (x + y));
    }

    //Different number of parameters
    public void Calculation(int i, int j, int k) {
        System.out.println("Sum of 3 numbers :" + (i + j + k));
    }

    //Different sequence of parameters
    public void Calculation(float p, int r) {
        System.out.println("Sum of 3 numbers :" + (p + r));
    }

    public static void main(String[] args) {

        MethodOverloading_Demo add = new MethodOverloading_Demo();

        //Call overloaded methods
        add.Calculation(5, 12f);
        add.Calculation(13f, 12.0f);
        add.Calculation(22, 33, 50);
        add.Calculation(11f, 10);
    }

}

The output of the above program is

What is Type Promotion?

When a data type of smaller type, promote to bigger type, it called type promotion.  Suppose a method has double data type and object provides float, then the program works fine. Float will be promote to double.

Let us explain this with an example. In the below example, object has provided float data type, but method has double data type, so there is type promotion.

public class Addition {

    public void Calculation(int a, int b)  {
        System.out.println("Sum of 2 numbers :"+(a+b));
    }

    public void Calculation(int x, double y)   {
        System.out.println("Sum of 2 numbers :"+(x+y));
    }

    public static void main(String[] args) {
        Addition add = new Addition();
        //Type Promotion method
        add.Calculation(5,12);
        add.Calculation(13,12f);
    }
}

The output of the above program is

We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

Multiple questions on Exception Handling in Java

Last Updated On

HOME

In this tutorial, you will see the various questions related to Exception Handling.

Example1

1. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {

		try {
			int a[] = new int[5];
			a[5] = 30 / 0;
		} catch (ArithmeticException e) {
			System.out.println("Arithmetic Exception occurs");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("ArrayIndexOutOfBounds Exception occurs");
		} catch (Exception e) {
			System.out.println("Parent Exception occurs");
		}
		System.out.println("Continue the program..");
	}
}

A. Arithmetic Exception occurs, Continue the program..
B. Continue the program..
C. Parent Exception occurs, Continue the program..
D. Continue the program..

Answer A. Arithmetic Exception occurs, Continue the program..

Here, we have multiple catch blocks with different types of exceptions. 30 is divided by 0 which throws ArithmeticException. So, the catch block for ArithmeticException is executed. Once the try-catch block is executed, the program runs in normal flow.

The output of the above program is

Example2

2. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {

		try {
			int a[] = new int[5];
			a[5] = 30 / 15;
		} catch (ArithmeticException e) {
			System.out.println("Arithmetic Exception occurs");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("ArrayIndexOutOfBounds Exception occurs");
		} catch (Exception e) {
			System.out.println("Parent Exception occurs");
		}
		System.out.println("Continue the program..");
	}
}

A. ArrayIndexOutOfBounds Exception occurs , Continue the program..
B. Continue the program..
C. Parent Exception occurs, Continue the program..
D. ArrayIndexOutOfBounds Exception occurs

Answer A. ArrayIndexOutOfBounds Exception occurs , Continue the program..

Here, we are trying to access a[5] where index 5 is out of range, which throws ArrayIndexOutOfBoundsException. So, the catch block for ArrayIndexOutOfBoundsException is executed. Once the try-catch block is executed, the program runs in normal flow.

The output of the above program is

Example3

3. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		try {
			int a[] = new int[5];

			System.out.println(a[7]);
		} catch (ArithmeticException e) {
			System.out.println("Arithmetic Exception occurs");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("ArrayIndexOutOfBounds Exception occurs");
		} catch (Exception e) {
			System.out.println("Parent Exception occurs");
		}
		System.out.println("Continue the program..");
	}
}

Output
ArrayIndexOutOfBounds Exception occurs
Continue the program..

A. ArrayIndexOutOfBounds Exception occurs , Continue the program..
B. Continue the program..
C. Parent Exception occurs, Continue the program..
D. ArrayIndexOutOfBounds Exception occurs

Answer A. ArrayIndexOutOfBounds Exception occurs , Continue the program..

Here, we are trying to access a[7] where index 7 is out of range, which throws ArrayIndexOutOfBoundsException. So, the catch block for ArrayIndexOutOfBoundsException is executed. Once the try-catch block is executed, the program runs in normal flow.

The output of the above program is

Example4

4. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		try {
			int a[] = new int[5];
			a[5] = 30 / 0;
			System.out.println(a[10]);
		} catch (ArithmeticException e) {
			System.out.println("Arithmetic Exception occurs");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("ArrayIndexOutOfBounds Exception occurs");
		} catch (Exception e) {
			System.out.println("Parent Exception occurs");
		}
		System.out.println("Continue the program..");
	}
}

A. Arithmetic Exception occurs , Continue the program..
B. ArrayIndexOutOfBounds Exception occurs , Continue the program..
C. Parent Exception occurs, Continue the program..
D. ArrayIndexOutOfBounds Exception occurs

Answer A. Arithmetic Exception occurs , Continue the program..

Here, the try block contains two exceptions. But at a time only one exception occurs and its corresponding catch block is executed. So, the first exception is 30 divided by 0 which throws an ArithmeticException. So, the catch block for ArithmeticException is executed. Once the corresponding catch block is executed, the program runs in normal flow.

The output of the above program is

Example5

5. Find the output of the following program.

public class ExceptionHandlingDemo {

    public static void main(String[] args) {
        try {
            String name = null;
            System.out.println(name.length());
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic Exception occurs");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBounds Exception occurs");
        } catch (Exception e) {
            System.out.println("Parent Exception occurs");
        }
        System.out.println("Continue the program..");
    }
}

A. NullPointerException , Continue the program..
B. ArrayIndexOutOfBounds Exception occurs , Continue the program..
C. Parent Exception occurs, Continue the program..
D. ArrayIndexOutOfBounds Exception occurs

Answer C. Parent Exception occurs, Continue the program..

Here, the try block contains NullPointerException. But, there is no NullPointerException present in any of the catch blocks. In such a case, the catch block containing the parent exception class Exception will be invoked.

The output of the above program is

Example6

6. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		try {
			int a[] = new int[5];
			a[5] = 30 / 0;
		} catch (Exception e) {
			System.out.println("common task completed");
		} catch (ArithmeticException e) {
			System.out.println("Arithmetic Exception occurs");
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("ArrayIndexOutOfBounds Exception occurs");
		}
		System.out.println("Continue the program..");
	}
}

A. Continue the program..
B. ArrayIndexOutOfBounds Exception occurs , Continue the program..
C. Parent Exception occurs, Continue the program..
D. Compile Time error

Answer D. Compile Time error

Here, the order of exceptions is not maintained like most specific to general exceptions. The exception is the parent exception, so should be mentioned as the last exception. As a result, there is a compile-time error.

The output of the above program is

Example7

7. Find the output of the following program.

public class ExceptionHandlingDemo {

    public static void main(String args[]) {
        int x = 0;
        int y = 10;
        int z = y/x;
    }
}

Here, ArithmeticException is an unchecked exception that is not checked at a compiled time. So the program compiles fine but throws ArithmeticException.

The output of the above program is

Example8

8. Find the output of the following program.

public class ExceptionHandlingDemo {

    public static void main(String[] args) {
        try {
            int a[] = { 1, 2, 3, 4 };
            for (int i = 1; i <= 4; i++) {
                System.out.println("a[" + i + "]=" + a[i]);
            }
        }

        catch (Exception e) {
            System.out.println("error = " + e);
        }

        catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBounds Exception occured");
        }
    }
}

Here, ArrayIndexOutOfBoundsException has been already caught by the base class Exception. When a subclass exception is mentioned after the base class exception, then an error occurs.

The output of the above program is

Example9

9. Find the output of the following program.

public class Example9 {

	public static void main(String[] args) {
		try {
			int a[] = { 1, 2, 3, 4 };
			for (int i = 1; i <= 4; i++) {
				System.out.println("a[" + i + "]=" + a[i]);
			}
		}

		catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("ArrayIndexOutOfBounds Exception occured");
		}

		catch (Exception e) {
			System.out.println("error = " + e);
		}
	}
}

Here, the try block prints a[1] to a[3] and then throws ArrayIndexOutOfBoundsException which is handled by the corresponding catch block.

The output of the above program is

Example10

10. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {

		// outer try block
		try {

			// inner try and catch block 1
			try {
				System.out.println("going to divide by 0");
				int b = 40 / 0;
			}
			catch (ArithmeticException e) {
				System.out.println(e);
			}

			// inner try and catch block 2
			try {
				int a[] = new int[5];

				// assigning the value out of array bounds
				a[5] = 4;
			}
			catch (ArrayIndexOutOfBoundsException e) {
				System.out.println(e);
			}

			System.out.println("No more inner try catch block");
		}

		// catch block of outer try block
		catch (Exception e) {
			System.out.println("Handled the exception of outer try");
		}

		System.out.println("Continue the program..");
	}
}

Here, the first inner try-catch block is executed. Then second inner try-catch block is executed and at last outer try-catch block is executed. Post all these, the program runs in normal flow.

The output of the above program is

Example11

11. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {

        // outer try block
        try {

            // inner try block 1
            try {

                // inner try block 2
                try {
                    int x = 25 / 0;
                    System.out.println("Value of x :" + x);
                }

                // to handles ArrayIndexOutOfBoundsException
                catch (ArrayIndexOutOfBoundsException e) {
                    System.out.println("Arithmetic exception");
                    System.out.println(" inner try block 2");
                }
            }

            // to handle ArrayIndexOutOfBoundsException
            catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("Arithmetic exception");
                System.out.println("inner try block 1");
            }
        }

        // to handle ArithmeticException
        catch (ArithmeticException e) {
            System.out.println(e);
            System.out.println("Outer try block");
        } catch (Exception e) {
            System.out.print("Exception");
            System.out.println("Handled in main try block");
        }
    }
}

Here, the try block within the nested try block (inner try block 2) does not handle the exception. The control is then transferred to its parent try block (inner try block 1) and it also does not handle the exception, then the control is transferred to the main try block (outer try block) where the appropriate catch block handles the exception. 

The output of the above program is

Example12

12. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {

		// outer try block
		try {

			// inner try block 1
			try {

				// inner try block 2
				try {
					int x = 25 / 0;
					System.out.println(x);
				}

				// to handles ArrayIndexOutOfBoundsException
				catch (ArrayIndexOutOfBoundsException e) {
					System.out.println("Arithmetic exception");
					System.out.println(" inner try block 2");
				}
			}

			// to handle ArithmeticException 
			catch (ArithmeticException e) {
				System.out.println("Arithmetic exception");
				System.out.println("inner try block 1");
			}
		}

		// to handle ArithmeticException
		catch (ArithmeticException e) {
			System.out.print(e);
			System.out.println("Outer try block");

		} catch (Exception e) {
			System.out.print("Exception");
			System.out.println("Handled in main try block");
		}
	}
}

Here, the try block within the nested try block (inner try block 2) does not handle the exception. The control is then transferred to its parent try block (inner try block 1) and it does handle the exception, so the catch block of inner try block 1 handles the exception.

The output of the above program is

Example13

13. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		try {
			// below code do not throw any exception
			int data = 25 / 5;
			System.out.println(data);
		}

		// catch won't be executed
		catch (NullPointerException e) {
			System.out.println(e);
		}

		// This is executed whether exception occurs or not
		finally {
			System.out.println("finally block is always executed");
		}

		System.out.println("Continue the Program ..");
	}
}

Output
5
finally block is always executed
Continue the Program ..

Here, no exception is thrown, so the catch block is not executed. finally block is always executed irrespective the catch block is executed or not.

The output of the above program is

Example14

14. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		try {

			System.out.println("Inside the try block");

			// below code throws divide by zero exception
			int data = 25 / 0;
			System.out.println(data);
		}

		catch (NullPointerException e) {
			System.out.println("Exception handled");
			System.out.println(e);
		}

		// executes regardless of exception occurred or not
		finally {
			System.out.println("finally block is always executed");
		}

		System.out.println("Continue the Program ..");
	}
}

Here, the code throws an exception, however, the catch block cannot handle it. Despite this, the finally block is executed after the try block and then the program terminates abnormally.

The output of the above program is

Example15

15. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		
       try {

			System.out.println("Inside try block");

			// below code throws divide by zero exception
			int data = 25 / 0;
			System.out.println(data);
		}

		// handles the Arithmetic Exception 
		catch (ArithmeticException e) {
			System.out.println("Exception is handled");
			System.out.println(e);
		}

		// executes regardless of exception occured or not
		finally {
			System.out.println("finally block is always executed");
		}

		System.out.println("Continue the Program ..");
	}
}

Here, the code throws an exception and the catch block handles the exception. Later the finally block is executed after the try-catch block. Further, the rest of the code is also executed normally.

The output of the above program is

Example16

16. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		try {
			int a = 0;
			System.out.println("a = " + a);
			int b = 20 / a;
			System.out.println("b = " + b);
		}

		catch (ArithmeticException e) {
			System.out.println("Divide by zero error");
		}

		finally {
			System.out.println("inside the finally block");
		}
	}
}

Here, a is printed. Then, 20 is divided by 0, which throws ArithmeticException and control goes inside the catch block. Also, the finally block is always executed whether an exception occurs or not.

The output of the above program is

Example 17

17. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		int data = 50 / 0; // may throw exception

		System.out.println("rest of the code");
	}

}

Here, there is no try-catch block. So, the error is thrown.

The output of the above program is

Example 18

18. Find the output of the following program.

public class ExceptionHandlingDemo  {

	public static void main(String[] args) {
		try {
			int data1 = 50 / 0; 

		}
		catch (Exception e) {
			// generating the exception in catch block
			String name = null;
			System.out.println(name.length());
			
		}
		System.out.println("Continue the Program ..");
	}

}

Output
Exception in thread "main" java.lang.NullPointerException

Here, the catch block didn’t contain the exception code. So, enclose the exception code within a try block and use a catch block only to handle the exceptions.

The output of the above program is

Example 19

19. Find the output of the following program.

public class ExceptionHandlingDemo {

	static void checkEligibilty(int age, int marks) {
		if (age < 18 && marks < 90) {
			throw new ArithmeticException("Student is not eligible for admission");
		} else {
			System.out.println("Student Entry is Valid!!");
		}
	}

	public static void main(String[] args) {
		System.out.println("Welcome to the Admission process!!");
		checkEligibilty(17, 80);
		System.out.println("Continue the Program ..");
	}
}

Here, an unchecked exception was thrown and it is not handled, so the program halts.

The output of the above program is

Example 20

20. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void myMethod(int testnum) throws Exception {
		System.out.println("start - myMethod");
		if (testnum < 100)
			throw new Exception();
		System.out.println("end - myMethod");
		return;
	}

	public static void main(String args[]) {
		int testnum = 90;
		try {
			System.out.println("try - first statement");
			myMethod(testnum);
			System.out.println("try - last statement");
		} catch (Exception ex) {
			System.out.println("An Exception");
		} finally {
			System.out.println("finally");
		}
		System.out.println("Out of try/catch/finally - statement");
	}
}

Here, an exception is thrown in the try block, which is handled by the catch block. A finally block is executed, and then the program continues as usual.

The output of the above program is

Example 21

21. Find the output of the following program.

public class ExceptionHandlingDemo {

   public static void main(String args[]) {
      try {
         throw 10;
      }
      catch(int e) {
         System.out.println("Got the  Exception " + e);
      }
  }
}

In Java, only throwable objects (Throwable objects are instances of any subclass of the Throwable class) can be thrown as exceptions. So basic data types can not be thrown at all.

The output of the above program is

Example 22

22. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String[] args) {
		
      try {
			throw new Test();
		} catch (Test t) {
			System.out.println("Got the Test Exception");
		} finally {
			System.out.println("Inside finally block ");
		}
	}
}

The output of the above program is

Example 23

23. Find the output of the following program.

class Base extends Exception {
}

class Derived extends Base {
}

 class ExceptionHandlingDemo  {

    public static void main(String[] args) {
        try {

            throw new Derived();
        } catch (Base b) {
            System.out.println("Caught base class exception");
        } catch (Derived d) {
            System.out.println("Caught derived class exception");
        }
    }
}

The output of the above program is

Example 24

24. Find the output of the following program.

public class ExceptionHandlingDemo {

	String str = "a";

    void A() {
        try {
            str += "b";
            B();
        } catch (Exception e) {
            str += "c";
        }
    }

    void B() throws Exception {
        try {
            str += "d";
            C();
        } catch (Exception e) {
            throw new Exception();
        } finally {
            str += "e";
        }

        str += "f";

    }

    void C() throws Exception {
        throw new Exception();
    }

    void display() {
        System.out.println(str);
    }

    public static void main(String[] args) {
        ExceptionHandlingDemo object = new ExceptionHandlingDemo();
        object.A();
        object.display();
    }

}

}

‘throw’ keyword is used to explicitly throw an exception.
Call to method C() throws an exception. Thus, control goes to the catch block of method B() which again throws an exception. Then finally block is always executed even when an exception occurs. Now, control goes to the catch block of method A().

The output of the above program is

Example 25

25. Find the output of the following program.

public class ExceptionHandlingDemo {

	 void m() {
        int data = 50 / 0;
    }

    void n() {
        m();
    }

    void p() {
        try {
            n();
        } catch (Exception e) {
            System.out.println("Exception Handled");
        }
    }

    public static void main(String args[]) {
        ExceptionHandlingDemo obj = new ExceptionHandlingDemo();
        obj.p();
        System.out.println("Continue the program..");
    }
}

Here, the exception occurs in the m() method where it is not handled, so it is propagated to the previous n() method where it is not handled, again it is propagated to the p() method where the exception is handled.

The output of the above program is

Example 26

26. Find the output of the following program.

public class ExceptionHandlingDemo {

	void m() {
        throw new IOException("device error");// checked exception
    }

    void n() {
        m();
    }

    void p() {
        try {
            n();
        } catch (Exception e) {
            System.out.println("Exception Handled");
        }
    }

    public static void main(String args[]) {
        ExceptionHandlingDemo obj = new ExceptionHandlingDemo();
        obj.p();
        System.out.println("Continue the program..");
    }
}

Here, the exception occurs in the m() method where it is not handled, so it is propagated to the previous n() method where it is not handled, it is propagated to the p() method where the exception is supposed to be handled, but as it is checked Exception which can not be handled by Exception.

The output of the above program is

Example 27

27. Find the output of the following program.

public class ExceptionHandlingDemo {

    void m() {
        throw new ArithmeticException("Arithmetic Exception occured ");
    }

    void n() {
        m();
    }

    void p() {
        try {
            n();
        } catch (Exception e) {
            System.out.println("Exception handled");
        }
    }

    public static void main(String args[]) {
        ExceptionHandlingDemo obj = new ExceptionHandlingDemo();
        obj.p();
        System.out.println("Continue the program..");
    }
}

a) Arithmetic Exception
b) Exception Handled, Continue the program..
c) Runtime Exception
d) Compile Time Error

Answer b) Exception Handled, Continue the program..

Here, the exception occurs in the m() method – ArithmeticException where it is not handled, so it is propagated to the previous n() method where it is not handled, again it is propagated to the p() method where the exception is handled.

The output of the above program is

Example 28

28. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String args[]) {
		try {
			int i, sum;
			sum = 10;
			for (i = -1; i < 3; ++i)
				sum = (sum / i);
		} catch (ArithmeticException e) {
			System.out.print("0");
		}
		System.out.print(sum);
	}
}

a) 0
b) -1
c) Runtime Exception
d) Compile Time Error

Answer c) Runtime Exception

Here, the value of the variable sum is printed outside of the try block, the sum is declared only in the try block, and outside try block it is undefined.

The output of the above program is

Example 29

29. Find the output of the following program.

public class ExceptionHandlingDemo {

	public static void main(String args[]) {
		try {
			String str = "beginnersbook";
			System.out.println(str.length());
			char c = str.charAt(0);
			c = str.charAt(40);
			System.out.println(c);
		} catch (StringIndexOutOfBoundsException e) {
			System.out.println("StringIndexOutOfBoundsException!!");
		}
	}
}

Here, an exception occurred because the referenced index was not present in the String.

The output of the above program is

Example 30

30. Find the output of the following program.

public class ExceptionHandlingDemo {

    public static void main(String[] args) {

            try {
                int num = Integer.parseInt("XYZ");
                System.out.println(num);
            } catch (StringIndexOutOfBoundsException e) {
                System.out.println("String IndexOutOfBounds Exception occurred!!");
            } catch (NumberFormatException e) {
                System.out.println("Number format exception occurred");
            } catch (Exception e) {
                System.out.println("Exception occurred");
            }
        }
    }

a) String IndexOutOfBounds Exception occurred!!
b) Number format exception occurred
c) Exception occurred
d) None

Answer b) Number format exception occurred

Here, an exception is not of type StringIndexOutOfBounds, so moved to the next catch where the exception is handled.

The output of the above program is

vibssingh

How to stash changes in GIT – git stash command

HOME

The previous tutorial has explained about committing the changes in GIT. This tutorial explains about stashing the changes in GIT.

Table of Contents

  1. What is git stash?
    1. How to reapply stashed changes?
    2. Stashing untracked or ignored files

What is git stash?

git stash temporarily stashes or shelves the changes made in the working copy so that we can work on something else and later apply these changes.

Imagine a situation where you are working on updating a feature, but suddenly there is a production bug in the existing functionality of the feature that needs to be fixed immediately. So, we need to switch to a bug fix and leave working on the update work. As the update work is not completed, we can stash these changes and work on the bug fix. Later, we can re-apply our stashed changes back to the code.

The git stash command can stash the uncommitted changes (both staged and unstaged), save them away for later use, and then revert them from your working copy. 

How to reapply stashed changes?

To re-apply the stashed changes, use this command

git stash pop

This command removes the changes from your stash and reapplies them to your working copy.

Alternatively, you can reapply the changes to your working copy and keep them in your stash with : 

git stash apply

Stashing untracked or ignored files

If a new file is created and not staged, then git stash is not going to stash that file.

Adding the -u option (or –include-untracked) tells git stash to also stash your untracked files:

git stash -u

Congratulation!! We have learned about stash in GIT.

vibssingh

CI/CD Interview Questions and Answers 2026

Last Updated On

HOME

1. What is CI/CD Pipeline?

CI/CD stands for Continuous Integration and Continuous Delivery (or Continuous Deployment), and it refers to a set of software development practices aimed at improving the efficiency, reliability, and speed of the software development and release process.

2. What’s the difference between continuous integration, continuous delivery, and continuous deployment?

Continuous Integration (CI) is a development practice wherein developers frequently merge their code modifications into a central repository. This integration occurs multiple times throughout the day and is validated through automated tests and a build procedure. This approach helps in mitigating integration issues, identifying and rectifying bugs early in the development phase, and iteratively testing and refining the code.

Continuous Delivery (CD) extends CI by automating the delivery of code changes up to a staging or pre-production environment. The goal is to ensure that code is always deployment-ready by the time it reaches these environments. Every change that passes all automated tests in the pipeline is prepared for deployment, though the actual release into production might still require manual approval.

Continuous Deployment (CD): The most critical stage of the pipeline is continuous deployment. Continuous Deployment takes CD a step further by automating the deployment of code changes directly to production. Every change that passes all pipeline stages is automatically released to users without manual intervention. Code changes can be made live much more quickly at this stage because there is little human interaction.

3. What are the benefits of the CI/CD Pipeline?

1. CI encourages frequent integration of code changes, promoting collaboration among team members. Developers can work on their features independently, knowing that automated processes will catch integration issues.

2. CI/CD automates the software delivery process, reducing manual interventions and streamlining workflows. This results in quicker development cycles and faster releases to production.

3. Automated testing in the CI phase helps identify bugs, errors, and integration issues early in the development cycle. This allows for prompt resolution and prevents the accumulation of issues that could be more challenging to address later.

4. CI improves transparency by detecting early-stage failures like build failures, merge issues, integration test failures, etc.

5. Automation in the CI/CD pipeline reduces the need for manual steps, minimizing the risk of human error and freeing up developers and operators to focus on more strategic and creative tasks. This also increases the quality of the code.

4. What are the popular CI/CD Tools?

There are several popular CI/CD (Continuous Integration/Continuous Delivery) tools available that help automate various stages of the software development lifecycle. Here are some widely used CI/CD tools:

1. Jenkins is an open-source automation server that supports building, deploying, and automating any project. It has a large and active community, extensive plugin support, and is highly customizable.

2. Travis CI is a cloud-based CI service that integrates with GitHub repositories. It’s known for its simplicity and ease of use, and it’s commonly used for open-source projects.

3. GitLab provides built-in CI/CD capabilities as part of its platform. It allows users to define CI/CD pipelines using a .gitlab-ci.yml file in the repository. GitLab CI/CD is tightly integrated with GitLab’s version control features.

4. CircleCI is a cloud-based CI/CD platform that supports the automation of the software development process. It integrates with popular version control systems, such as GitHub and Bitbucket.

5. GitHub Actions is a CI/CD and automation service provided by GitHub. It allows developers to define workflows using YAML files within the repository. GitHub Actions seamlessly integrates with GitHub repositories.

6. Atlassian Bamboo is a CI/CD server that integrates with other Atlassian tools like Jira and Bitbucket. It supports building, testing, and deploying applications.
TeamCity:

7. TeamCity, developed by JetBrains, is a CI/CD server with support for various build and deployment scenarios. It has a user-friendly interface and integrates with popular version control systems.

8. Azure DevOps, previously known as Visual Studio Team Services (VSTS), provides a set of development tools, including CI/CD capabilities. It integrates with Microsoft’s Azure cloud services.

5. What are “Artifacts” in the context of CI/CD, and why are they important?

Artifacts are the output of a CI/CD pipeline, typically binary or deployable files such as executables, libraries, Docker images, or Reports.

1. Storing artifacts in dedicated repositories enables easy access and sharing among team members involved in the CI/CD pipeline.

2. Artifacts ensure that deployments are consistent and reproducible across different environments.

3. Artifacts provide a way to track and manage different versions of your software.

6. What are the major phases of the CI/CD pipeline?

There are four phases of the CI/CD pipeline. These are as follows.

1. Source – The first phase in a CI/CD pipeline is the creation of source code. During this phase, developers translate requirements into functional algorithms. They also create behaviors and features.

2. Build – The build process draws source code from a repository, establishes links to relevant libraries, modules, and dependencies, and compiles (builds) all these components into an executable (.exe) file.

3. Test – The source code has already completed some static testing. The completed build now enters the next CI/CD phase of comprehensive dynamic testing. This usually starts with basic functional or unit testing. This verifies that new features and functions work as intended. Regression testing is also conducted. This ensures that new changes or additions do not accidentally break any previously working features.

4. Deploy – The deployment step typically involves creating a deployment environment — for example, provisioning resources and services within the data center — and moving the build to its deployment target, such as a server.

7. What are the vital steps in designing a CI/CD pipeline?

Designing a CI/CD pipeline involves several key steps:

1. Define Objectives and Scope – Outline the goals of implementing CI/CD. These goals can include improving deployment frequency, reducing errors, or enhancing collaboration. Determine the scope of the pipeline: which projects, applications, or services it will cover.

2. Set up a Version Control System (VCS) – We need to establish a version control system. This ensures all code changes are tracked and promotes collaborative development. A tool like Git is commonly used for this purpose.

3. Choose the Right Tools – Select appropriate CI/CD tools based on your technology stack and team expertise. Popular tools include Jenkins, GitLab CI/CD, CircleCI, and AWS CodePipeline. Make sure of integration with version control systems (e.g., Git), build tools, and other development tools you use.

4. Automate Code Builds –  We need to set up a build system. Design build scripts to automatically compile code and handle dependencies. Ensure the build process is reproducible and consistent across different environments. Most commonly used tools suited to the programming language, such as Maven or Gradle for Java, or npm for JavaScript.

5. Implement Automated Testing – We need robust automated testing mechanisms. Immediately after a successful build, you want to run all your unit tests. As the code progresses through the pipeline, additional tests come into play. These include integration, functional, and security checks. Quality assurance at every stage reduces the risk of potential bugs getting into the production.

6. Incorporate Code Analysis and Security Checks – Apply static and dynamic analysis tools within the pipeline to enforce code quality standards and detect security vulnerabilities early. Tools like SonarQube, OWASP ZAP, or Checkmarx can be useful for this purpose.

7. Set Up Deployment Automation – Automate the deployment process to various environments (development, testing, and production). Use configuration management tools such as Ansible or Terraform. Decide on deployment strategies, such as blue-green deployments or canary releases, to minimize downtime and risk.

8. Implement Monitoring and Logging – Integrate monitoring tools to track the performance and reliability of your applications post-deployment.

9. Define Rollback Procedures – Prepare for failure scenarios by defining clear rollback and remediation procedures. Automated rollbacks can help reduce downtime in case of deployment issues.

10. Regularly Review and Optimize – Continuously review and update the CI/CD pipeline to address bottlenecks, improve efficiency, and adapt to changing requirements.

8. How do you trigger a CI/CD pipeline?

A CI/CD pipeline can be triggered in several ways. It can be activated by Code Push, scheduled trigger, manual initiation, and Continuous Integration.

1.Code Pushes – Pipelines can be triggered automatically when code is pushed to a particular branch in a version control system like Git.

2. Pull Requests/Merge Requests – Another frequent trigger is the creation or updating of pull requests or merge requests. Pipelines can run tests and checks on feature branches before they are merged into the main branch.

3. Scheduled Triggers – Pipelines can be set to run at regular intervals using scheduled jobs. This might be used to perform nightly builds, run daily tests, or generate periodic reports.

4. Manual Triggers – Users can manually trigger pipelines or specific pipeline stages. This flexibility is useful for executing on-demand tasks, such as deploys to specific environments or running full test suites.

5. CI/CD Tool-Specific Triggers – Many CI/CD tools, such as Jenkins, GitLab CI/CD, and CircleCI, provide specific interfaces and jobs that can be configured to start pipelines under particular conditions defined within the toolsets.

6. External Event Integration – Triggers can be set up based on external events, like infrastructure changes (e.g., changes in cloud resource state) which can kick off a deployment pipeline.

9. In what situations would a Continuous Deployment strategy not be appropriate?

Continuous Deployment offers numerous benefits. These include rapid iterations, faster time to market, and accelerated feedback. However, it is not suitable for every scenario.

1. Highly Regulated Industries – In regulated industries such as finance or healthcare, there are often stringent regulations. Compliance requirements include intensive manual reviews and audits before each software release. Automated, frequent changes could be risky in such scenarios.

2. Critical Systems with High Reliability Requirements – The product’s users are businesses that heavily depend on your application. Examples include avionics software or medical devices. These users may prefer stability. Sudden changes could disrupt their workflow. Continuous deployment may not be the best approach. These users would likely prefer scheduled updates to prepare for changes.

3. Complex Approval Processes – If the organization requires a complex set of approval steps, it might not be feasible to implement a continuous deployment strategy. These steps can involve multiple stakeholders, such as legal, marketing, or compliance departments.

4. Limited Test Automation – If the organization lacks sufficient test automation to confidently validate changes before they reach production, continuous deployment could introduce unnecessary risks and potential for increased defects in production.

5. Lack of skilled resources – If your team is not accustomed to high-frequency changes, it may struggle. Teams also may lack the skillset to manage such a fast-paced environment. Forcing continuous deployment might lead to more problems. This continues until the processes and team have matured.

10. How do you monitor a CI/CD pipeline?

Monitoring a CI/CD pipeline is crucial to ensuring it works efficiently, reliably, and is always ready for a new deployment. 

1. Utilize Integrated Monitoring Tools – Many CI/CD platforms come with built-in monitoring tools that provide real-time insights into pipeline operations. These tools can track the status of builds, deployments, and test executions.

2.  Set Up Alerts and Notifications – Configure alerts and notifications for key events, such as build failures, deployment issues, or test result anomalies. For instance, in the Jenkins platform, each job’s status can be visually tracked and logs accessed directly. If a job fails, Jenkins can notify users automatically via email or other messaging platforms.

3. Monitor Key Metrics – Track important metrics, including build duration, success/failure rate, deployment frequency, and test result trends. These metrics give insight into the pipeline’s health and efficiency.  It helps in identifying bottlenecks in the process and guides optimization efforts.

4. Visualize Pipeline Status – Use dashboards to provide a holistic view of the pipeline’s status, showing the progress of builds, tests, and deployments.

5. Log Monitoring and Analysis – Implement logging for all stages of the pipeline, capturing detailed information about build processes, errors, and test outputs. Tools like Prometheus, Grafana, or ELK stack can come in handy for this purpose.

6. Continuous Feedback Loops – Establish feedback loops for capturing input from developers and operations teams about ongoing runs. This helps in proactively identifying areas for improvement.

11. What are common causes of failures in CI/CD pipelines, and how can they be mitigated?

1. Code Quality Issues –  Poor code quality can lead to build failures, failed tests, or runtime errors.  Implement static code analysis tools (e.g., SonarQube, ESLint) to identify issues early.

2. Flaky Tests – Tests that intermittently pass or fail lead to unreliable pipeline results.  Analyze and refactor flaky tests to make them more reliable. Review dependencies and test setup to ensure consistency. Use isolation approaches, such as mocking dependencies.

3. Dependency Issues – Update in the version of external libraries or services can introduce incompatibilities or failures. Specify dependency versions and use dependency management tools to maintain control over updates.

4. Resource Constraints – Insufficient resources, such as CPU, memory, or disk space, can lead to pipeline slowdowns or failures. Monitor resource usage and scale resources as necessary, especially with cloud-based solutions. Optimize pipeline scripts for efficiency.

5. Configuration Errors – Misconfigurations in the pipeline setup, such as incorrect paths, environment variables, or deployment settings, can cause failures. Use versioned configuration files and document configurations clearly. Implement configuration validation checks in the pipeline.

6. Security Vulnerabilities – Introduction of vulnerabilities during builds can halt deployments due to failed security checks. Integrate security scanning and testing within the pipeline to automatically detect vulnerabilities. Tools like OWASP ZAP or Checkmarx can be useful.

12. What is version control?

Version control involves the use of a central repository where teammates can commit changes to files and sets of files. The purpose of version control is to track every line of code, and to share, review, and synchronize changes between team members. The following are some of the most popular version control tools:

  • Mercurial
  • Subversion (SVN)
  • Concurrent Version System (CVS)
  • Perforce
  • Bazaar
  • Bitkeeper
  • Fossil

13. What is git?

Git is a mature, actively maintained open-source revision control system used by thousands of developers around the world.
It enables developers to track changes in their source code during software development.

14. What is git repository?

A Git repository is a storage where all the code alterations and version histories for a particular project are kept. A Git repository is the .git/ folder inside a project. This repository tracks all changes made to files in your project, building a history over time. Meaning, if you delete the .git/ folder, then you delete your project’s history.

15. What is git branch?

In Git, a branch is a parallel line of development that represents an independent line of work within a Git repository. Branches let developers code without affecting the work of other team members.

16. What is merging?

Merging in Git refers to the process of integrating changes from one branch into another. When developers work on separate branches to implement features, bug fixes, or other changes, merging is used to combine those changes back into a common branch, often the main or default branch.

17. What is test coverage?

Test coverage is a metric that measures how much of the codebase is covered by tests. A 100% coverage means that every line of the code is tested at least by one test case.

18. What is the role of automation in CI/CD?

1. Automation is used to trigger and execute builds automatically whenever changes are made to the version control repository.

2. It also ensures process uniformity and lowers the possibility of human error.

3. Automation is used to set up and configure monitoring and observability tools. Automated monitoring provides insights into the health and performance of applications in real-time.

19. How to write CI/CD pipeline in Jenkins?

To write a CI/CD pipeline in Jenkins, Install Jenkins and required plugins, Set up version control such as Git, Create a Jenkins file with build, test, and deploy stages, and Save Jenkinsfile to the repository. Then, Create a Jenkins job linked to the Jenkinsfile and trigger the job for the automated CI/CD process.

20. What is a Jenkins file?

A Jenkins file is a text file that contains a pipeline’s configuration. It outlines the pipeline’s stages, such as build, test, and deployment, as well as the actions that must be taken at each one.

Example of a Jenkins File:

pipeline {
    agent any
 
    stages {
        stage('Test') {
            steps {
                bat "mvn -D clean test"
            }
 
            post {                
                // If Maven was able to run the tests, even if some of the test
                // failed, record the test results and archive the jar file.
                success {
                   publishHTML([
                       allowMissing: false, 
                       alwaysLinkToLastBuild: false, 
                       keepAll: false, 
                       reportDir: 'target/surefire-reports/', 
                       reportFiles: 'emailable-report.html', 
                       reportName: 'HTML Report', 
                       reportTitles: '', 
                       useWrapperFileDirectly: true])
                }
            }
        }
    }
}

21. What is docker?

Docker is an open platform for developing, shipping, and running applications using containers. Containers allow a developer to package up an application with all the parts it needs, such as libraries and other dependencies, and ship it all out as one package. This ensures that the application runs consistently across different environments.
A Dockerfile is a text file that contains instructions for building a Docker image. It specifies the base image, the application code, dependencies, and other configuration settings needed to create the image.

22. What role does Docker play in CI/CD?

Docker plays a significant role in CI/CD processes by providing a consistent and efficient environment for developing, testing, and deploying applications.

1. Consistency Across Environments – Docker enables the creation of containerized environments that are consistent across different stages of the CI/CD pipeline. 

2. Efficiency – Docker containers are lightweight and can be quickly started, stopped, or replicated, which speeds up the testing and deployment processes. This efficiency is crucial for rapid iterations in a CI/CD pipeline.

3. Automation and Integration – Docker easily integrates with various CI/CD tools and platforms like Jenkins, GitLab CI, and AWS CodePipeline. This allows automated builds, tests, and deployments to be carried out within containers, streamlining the entire process.

4. Simplified Setup and Configuration – With Docker, you can define the entire environment setup in a single Dockerfile, which automates the creation of the development and deployment environments. This reduces setup time and configuration errors.

5. Scalability – Docker supports horizontal scaling by allowing you to deploy multiple instances of an application component across different containers. This helps manage increased load and optimize resource usage.

6. Version Control for Environments – Docker images can be version-controlled, allowing you to track changes to application environments, roll back to previous versions, and maintain a history of environment configurations

7. Resource Optimization – Docker helps in optimizing resource utilization by sharing the host operating system’s kernel and reducing the need for duplicating system libraries and files, which is a common issue in full-fledged virtual machines.

23. What are the best practices for using Docker in a CI/CD pipeline?

1. Use a Dockerfile – Create a well-structured Dockerfile for building your application images. Ensure that it is clean, efficient, and uses layers effectively to minimize the build time and size of the images.

2. Version Control Docker Images – Tag Docker images with both version numbers and descriptive tags (e.g., `version-1.0`, `latest`) to keep track of different builds and ensure you can revert or deploy specific versions when needed.

3. Implement Automated Builds and Tests – Set up automated processes to build Docker images and run tests as part of your CI/CD pipeline. This ensures that images are always up-to-date and validated through consistent testing.

4. Security Scans – Regularly scan Docker images for vulnerabilities using security tools such as Clair or Trivy. Address any identified security issues promptly and ensure compliance with security policies.

5. Environment Variables – Use environment variables to configure different environments (development, staging, production). Avoid hardcoding sensitive information directly in Dockerfiles or codebases.

6. Network Best Practices –  Use Docker’s network abilities smartly to segregate services within containers and implement proper network security measures like firewalls or network policies.

7. Logging and Monitoring – Integrate logging mechanisms within Docker containers to capture logs for monitoring and troubleshooting.

8. Regular Cleanup – Implement processes to regularly clean up unused Docker images and containers on your CI/CD servers to avoid storage bloat and keep the environment clean.

24. What is a container?

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another.

25. How can containerization improve the CI/CD process?

Containerization can greatly enhance the CI/CD process by providing consistent, isolated, and reproducible environments for developing, testing, and deploying applications.

1. Consistency Across Environments – Containers ensure consistent application performance. They run the same regardless of where they are deployed. This is achieved by bundling the application with its dependencies and environment configurations. 

2. Rapid Deployment and Scaling – Containers are lightweight and fast to start, enabling rapid deployment and scalability of applications. This quick start-up time is particularly beneficial in CI/CD pipelines where frequent builds and deployments are common.

3. Efficient Resource Utilization – Containers use system resources more efficiently than traditional virtual machines, reducing overhead and lowering costs. This efficiency allows more applications and services to be tested and deployed simultaneously within CI/CD processes.

4. Integration with Orchestration Tools – Container orchestration platforms like Kubernetes provide advanced features. These include automated scaling, load balancing, and rolling updates. These platforms offer robust support for managing containerized applications in a CI/CD workflow.

5. Easier Rollbacks – The immutability of container images ensures quick rollbacks to previous application versions. This is done by redeploying earlier image versions. It simplifies the rollback process in case of issues.

6. Improved Testing Process – Containers can create environments that closely mimic production. This facilitates better quality assurance. It also enhances testing within the CI/CD pipeline. Automated tests can be run consistently across development, staging, and production stages.

26. What is Kubernetes?

Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. Kubernetes can automatically scale the number of containers based on demand. It can also distribute incoming network traffic across multiple containers to ensure optimal performance and availability.

1. Service discovery and load balancing Kubernetes can expose a container using the DNS name or using their own IP address. If traffic to a container is high, Kubernetes can load balance and distribute the network traffic so that the deployment is stable.

2. Kubernetes supports rolling updates, allowing applications to be updated with minimal downtime. If an update causes issues, Kubernetes supports easy rollbacks to a previous version.

3. Kubernetes restarts containers that fail, replaces containers, kills containers that don’t respond to your user-defined health check, and doesn’t advertise them to clients until they are ready to serve.

4. Kubernetes lets you store and manage sensitive information, such as passwords, OAuth tokens, and SSH keys. You can deploy and update secrets and application configuration without rebuilding your container images, and without exposing secrets in your stack configuration.

27. What is blue-green deployment?

Blue-green deployment is a deployment approach in which new versions of an application are deployed and tested in two identical environments, blue and green.


The old version can be called the blue environment while the new version can be known as the green environment.

The new version in the Green environment is verified. Once it is considered stable, traffic is switched from the Blue environment to the Green environment.

If any issues arise with the new version shortly after switching, the team can quickly switch traffic back to the Blue environment. This reverts to the previous version.

Tools like Kubernetes, AWS Elastic Beanstalk, and some Continuous Delivery platforms offer built-in support for blue-green deployments.

28. What is canary deployment?

Canary deployment is a method of application deployment in which just a small percentage of production traffic is sent to a new version of the application, with the majority of traffic still being handled by the older version. As a result, the new version can be tested and validated before being implemented across the board in the production environment.

29. What is observability?

Observability is the ability to understand and diagnose the behavior of a complex system, such as a software application, using real-time monitoring and metrics.

30. What is Grafana?

  1. Grafana is an open-source analytics and monitoring platform that integrates with various data sources to help users visualize and understand their data. It is widely used for monitoring and observability in IT systems, providing a flexible and customizable interface for creating dashboards, charts, and graphs.
  2. Users can create dashboards that display real-time or historical data through the use of panels and visualizations.
  3. Grafana allows users to set up alert rules based on defined thresholds or conditions. When an alert is triggered, Grafana can send notifications via various channels, such as email, Slack, or other supported notification services.
  4. Grafana supports user authentication and authorization. Users can be organized into teams with specific access permissions, ensuring secure access control to dashboards and data sources.

31. What is Prometheus?

Prometheus is an open-source systems monitoring and alerting toolkit originally built at SoundCloud.
Prometheus employs a pull-based model, where it regularly scrapes (pulls) metrics from endpoints exposed by the systems being monitored. This model is well-suited for dynamic and containerized environments.
Prometheus Query Language (PromQL) is a powerful query language that allows users to retrieve and analyze metrics data. It supports various aggregation functions, filtering, and mathematical operations.
Prometheus includes a built-in alerting system that allows users to define alert rules based on metric thresholds or conditions. When an alert is triggered, Prometheus can send notifications to external systems.

32. How do you ensure the security of the CI/CD pipeline? or

How do you handle secret management in your CI/CD pipelines?

1.  Access Control and Authentication – To prevent unauthorized access to the pipeline and its components, access controls are essential. Authentication procedures must also be put in place. Use strong authentication mechanisms, such as multi-factor authentication (MFA), for accessing CI/CD tools.Implement strict access controls to ensure only authorized personnel can access sensitive parts of the pipeline. This can be managed by using role-based access control (RBAC).

2. Code Review and Static Analysis – Finding security flaws by checking code and dependencies for vulnerabilities and using static and dynamic analysis methods. Make sure all code changes undergo peer review to identify potential vulnerabilities before integration.

3. Secure Secrets Management – Avoid storing sensitive information, such as API keys and credentials, directly in CI/CD configuration files or scripts. Use secure vaults or secret management tools to store and retrieve secrets securely. Ensure that secrets are not exposed in logs. Rotate secrets regularly and audit access to secrets to prevent unauthorized usage.

4. Environment Security – Segregate environments used for development, testing, and production to minimize the risk of cross-environment leakages. Apply network security best practices, such as firewalls and intrusion detection systems, to protect the infrastructure.

5. Dependencies and Third-party Libraries – Utilize tools that can identify and report on security vulnerabilities in third-party dependencies. Update dependencies to patched versions to mitigate potential risk. Use package managers with integrated security tools that automatically check for vulnerabilities.

6. Automated Testing – Add automated security tests to the CI/CD pipeline. These tests can include penetration testing and vulnerability scanning. They should be part of the continuous integration process.

33. What are some challenges in implementing CI/CD?

1. Integrating CI/CD practices into existing legacy systems can be challenging.

2. Managing dependencies, especially in large projects, can be complex. Dependency management issues may arise from compatibility problems, version conflicts, or unavailability of required dependencies.

3. Security is a critical aspect of software development, and integrating security into CI/CD pipelines is a challenge. Ensuring secure coding practices, vulnerability scanning, and compliance checks requires careful consideration.

4. Integrating CI/CD pipelines with external tools, services, or platforms can be challenging. Ensuring compatibility and smooth interactions with tools like version control systems, issue trackers, and cloud services is essential.

34. Can you explain the concept of “Infrastructure as Code” (IaC) and provide an example of an IaC tool?

Infrastructure as Code (IaC) is the practice of managing and provisioning infrastructure using code and automation.  Instead of manually configuring servers, networks, and other infrastructure components, IaC allows developers to define and manage their infrastructure through code. One popular example of an IaC tool is Terraform which uses a domain-specific language (HCL — HashiCorp Configuration Language) to describe infrastructure resources and their relationships. With Terraform, you can create, update, and manage infrastructure as code, making it easier to version control and maintain infrastructure configurations.

35. Is CI/CD pipeline can be targeted by attackers?

Yes, CI/CD pipeline can be targeted by the attackers. CI/CD pipelines have access to various sensor data, such as server passwords, repositories, API keys, and so on. If the CI/CD system is not properly secured, then it can be targeted by attackers. A few ways of securing the CI/CD systems are as follows.

Finding security flaws by checking code and dependencies for vulnerabilities and using static and dynamic analysis methods.

To prevent unauthorized access to the pipeline and its components, access controls and authentication procedures must be put in place.

36. What is the meaning of trunk-based development in CI/CD?

Trunk-based development is a software development approach that emphasizes frequent integration of code changes into a shared main branch, often referred to as the “trunk” or “master” branch. In the context of CI/CD, trunk-based development promotes continuous integration by encouraging developers to merge their changes into the main branch multiple times throughout the day.

37. Describe the role of container orchestration tools in CI/CD.

Container orchestration tools like Kubernetes automate the deployment, scaling, and management of containerized applications in CI/CD pipelines.

38. What is chaos engineering?

Chaos engineering is the practice of intentionally introducing failures and chaos into a system to test its resilience and reliability. The practice involves identifying potential weaknesses in a system. This is done by intentionally injecting faults in a controlled manner. It also involves simulating failures to find failure points.

Popular tools for implementing chaos engineering include Gremlin and Chaos Monkey. Chaos Monkey was originally from Netflix. These tools are designed to introduce controlled failure scenarios into systems. They test the systems’ resiliency.

39. What is a microservices architecture?

A microservices architecture divides an application into smaller, independent services that can be developed, deployed, and scaled separately.

40. Can you explain the concept of “canary releases” in the context of CI/CD??

A canary release is a deployment strategy used to gradually roll out new software changes. Initially, it is provided to a small subset of users before making it available to the entire user base. This is used for uptime and user experience in web applications. Canary releases are suitable for frequent deployments with low-risk exposure.

Benefits:

Risk Mitigation: Deploy the new version to a limited audience initially. This way, you can identify potential issues without affecting all users. This controlled release helps in reducing the risk of widespread disruptions.

Real-World Testing: Canary releases provide an opportunity to test software in real-world conditions. These conditions can be more revealing than test environments.

Feedback Loop: Early adopters can provide feedback on the new release. This feedback can be used to make additional improvements. It can also be used for fixes before a full rollout.

41. Can you describe a scenario where a CI/CD pipeline failed and how you resolved it?

Absolutely. One day, the pipeline started failing consistently at the build stage. The failure logs indicated issues related to dependency mismatches, resulting in errors about incompatible versions. The problem arose after an external library that the project relied on received a major update with introduced breaking changes.

 As a quick fix, the team pinned the dependencies to the previous stable versions by updating the project’s dependency management file (like `package.json` for JavaScript or `requirements.txt` for Python).

To ensure future stability, the team added a task to the pipeline to run automated dependency checks regularly. This task alerts developers to any new breaking changes in external libraries.

We have updated documentation and workflow processes. These updates remind developers to always explicitly define dependencies. They should consider version changes carefully.

42. What are some best practices for handling external dependencies in CI/CD pipelines?

1.Use a Central Dependency Management Tool – We should use a dependency management tool specific to the programming environment. Examples include Maven for Java, npm for JavaScript, or pip with requirements.txt for Python. These tools help automate dependency resolution and version management.

2. Specify Dependency Versions – We should specify exact versions for all dependencies rather than using latest or wildcard versions (e.g., `1.2.3` instead of `^1.2.3`). This prevents unexpected breaking changes due to updates in external libraries.

3. Implement Local/Cached Repositories – We should use local or proxied repositories (e.g., JFrog Artifactory, Nexus Repository) to cache dependencies, ensuring builds do not rely on external network availability and reducing download times.

4. Automate Dependency Updates – It is recommended to use tools like Dependabot or Renovate to automate the process of checking for and updating dependency versions. These tools create pull requests with updates, allowing for review and integration testing before merging.

5. Conduct Dependency Audits and Security Scans – Regularly audit dependencies for known vulnerabilities. Use tools like OWASP Dependency-Check, Snyk, or npm audit. Automate these checks within the CI/CD pipeline to catch vulnerabilities early.

6. Regularly Clean Up Unused Dependencies – Periodically review unused dependencies. Remove them to minimize the attack surface. This will reduce complexity in the project.

vibssingh

JMeter Tutorials

Last Updated On

HOME

Apache JMeter is a popular open-source performance testing tool. It is a 100% pure Java application designed to load test functional behaviour and measure performance. It was originally designed for testing Web Applications but has since expanded to other test functions.

Category 1: Introduction and Installation

Chapter 1 Introduction of JMeter
Chapter 2 How to download and install Apache JMeter
Chapter 3  Install Apache JMeter in Ubuntu

Category 2: Basic Request Testing in JMeter

Chapter 1 How to send GET Requests in JMeter
Chapter 2 How to send POST requests in JMeter
Chapter 3 JMeter Authorization with access token
Chapter 4 Step-by-Step Guide to Test SOAP Services with JMeter – NEW

Category 3: Advanced Functionalities and Techniques

Chapter 1 How to generate Random Variables in JMeter
Chapter 2 How to use Response Assertion in JMeter
Chapter 3 How to create Web Test Plan for JMeter?
Chapter 4 How to parameterize requests in Jmeter
Chapter 5 Database Load Testing with JMeter: A Step-by-Step Guide – NEW
Chapter 6 How to Save JMeter Test Results as CSV and XML Files – NEW

Category 4: Reporting and Execution

Chapter 1 How to run JMeter tests from the command line
Chapter 2 How to generate JMeter HTML Report?

Category 5: Timers in JMeter

Chapter 1  Constant Throughput Timer in JMeter
Chapter 2 How to use Uniform Random Timer in JMeter
Chapter 3 How to use Constant Timer in JMeter

Category 6: CI/CD Integration

Chapter 1 How to use the JMeter Maven Plugin
Chapter 2 Integration of JMeter with Jenkins
Chapter 3 GitHub JMeter Integration – NEW

Category 7: Multiple Choice Questions

Chapter 1 JMeter Multiple Choice Questions – MCQ1 – NEW
Chapter 2 JMeter Multiple Choice Questions – MCQ2 – NEW

vibssingh

How to verify the response time of a request in Rest Assured?

Last Updated On

HOME

REST Assured provides a convenient way to retrieve and assert response time. Rest Assured provides a method to get response time in milliseconds by default or the time unit we want. We can also validate if the response time is less than, greater than, or in between the expected values as well.

Interface ResponseOptions

This interface contains four methods:-

  1. getTime() – The response time in milliseconds (or -1 if no response time could be measured)
  2. getTimeIn(TimeUnit timeunit) – The response time in the given time unit (or -1 if no response time could be measured)
  3. time() – The response time in milliseconds (or -1 if no response time could be measured)
  4. timeIn( TimeUnit timeunit ) – The response time in the given time unit (or -1 if no response time could be measured)

Technically, getTime() and time() both are the same, and getTimeIn() and timeIn() both are the same.

Below is an example.

import io.restassured.RestAssured;
import io.restassured.response.Response;
import io.restassured.specification.RequestSpecification;
import org.junit.Test;
import java.util.concurrent.TimeUnit;

public class ResponseTime {


    @Test
    public void getResponseTime() {

        RequestSpecification  requestSpecification = RestAssured.given();

        // Calling GET method
        Response response = requestSpecification.get("https://reqres.in/api/users/2");

        // Let's print response body.
        String resString = response.prettyPrint();
        System.out.println("Response Details : " + resString);

        //Get Response Time
        System.out.println("Response Time in milliseconds: " + response.getTime());

        System.out.println("Response Time in seconds: " + response.getTimeIn(TimeUnit.SECONDS));

        System.out.println("Response Time in milliseconds: " + response.time());

        System.out.println("Response Time in seconds: " + response.timeIn(TimeUnit.SECONDS));

    }

    }

The output of the above program is

Interface ValidatableResponseOptions

This interface has overloaded time() methods that accept Matcher.

  1. time(Matcher matcher) – Validate that the response time (in milliseconds) matches the supplied matcher.
  2. time(Matcher macther, TimeUnit timeunit) – Validate that the response time matches the supplied matcher and time unit.

Below is an example.

import org.hamcrest.Matchers;
import org.junit.Test;
import static io.restassured.RestAssured.given;

public class ResponseTime {

    @Test
    public void verifyResponseTime() {

        // Given
        given()

                // When
                .when()
                .get("https://reqres.in/api/users/2")

                // Then
                .then()
                .statusCode(200).statusLine("HTTP/1.1 200 OK")

                // Asserting response time is less than 2000 milliseconds
                .time(Matchers.lessThan(3000L));

    }
}

The output of the above program is

In the above example, we can see that the time taken by the request to provide the response is 3591 ms, which is greater than 3000 ms, so the test failed.

Similarly, we can use greaterthan() method too.

    @Test
    public void verifyGreaterResponseTime() {

        // Given
        given()

                // When
                .when()
                .get("https://reqres.in/api/users/2")

                // Then
                .then()
                .statusCode(200).statusLine("HTTP/1.1 200 OK")

                // Asserting response time is greater than 3000 milliseconds
                .time(Matchers.greaterThan(2000L));
    }

The output of the above program is

If you want to verify the time range, it can also be done using the Matchers. Below is an example of the same.

    @Test
    public void verifyResponseTimeRange() {

        // Given
        given()

                // When
                .when()
                .get("https://reqres.in/api/users/2")

                // Then
                .then()
                .statusCode(200).statusLine("HTTP/1.1 200 OK")

                // Asserting response time is greater than 1000 milliseconds and less than 2000 milliseconds
                .time(Matchers.both(Matchers.greaterThanOrEqualTo(1000L)).and(Matchers.lessThanOrEqualTo(2000L)));
    }

The output of the above program is

In the above example, the response time is 2550 ms, which does not fall in the range of 1000-2000 ms. So, the test is failed.

We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

Marshalling- How to convert Java Objects to XML using JAXB

Last Updated On

HOME

This tutorial explains how to use JAXB (Java Architecture for XML Binding) to convert Java Objects to XML documents.

JAXB provides a fast and convenient way to marshal (write) Java Objects into XML and un-marshal (read) XML into Java Objects. It supports a binding framework that maps XML elements and attributes to Java fields and properties using Java annotations.

With Java releases lower than Java 11, JAXB was part of the JVM and you could use it directly without defining additional libraries.

As of Java 11, JAXB is not part of the JRE anymore, and you need to configure the relevant libraries via your dependency management system, for example, either Maven or Gradle.

Configure the Java compiler level to be at least 11 and add the JAXB dependencies to your pom file.

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>JAXBDemo</artifactId>
  <version>0.0.1-SNAPSHOT</version>

  <name>JAXBDemo</name>
  <url>http://www.example.com</url>

  <properties>  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.plugin.version>3.11.0</maven.compiler.plugin.version>
    <maven.surefire.plugin.version>3.2.1</maven.surefire.plugin.version>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
  </dependency>
    
 <dependency>
    <groupId>com.sun.xml.bind</groupId>
    <artifactId>jaxb-impl</artifactId>
    <version>4.0.4</version>
   </dependency>
 </dependencies>
   
<build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${maven.surefire.plugin.version}</version>
        <configuration>
          <testFailureIgnore>true</testFailureIgnore>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.plugin.version}</version>
        <configuration>
          <source>${maven.compiler.source}</source>
          <target>${maven.compiler.target}</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

JAXB Annotations

  1. @XmlRootElement: Define the root element for an XML tree
  2. @XmlType: Define the order in which the fields are written in the XML file
  3. @XmlElement: Define the actual XML element name which will be used
  4. @XmlAttribute: Define the id field is mapped as an attribute instead of an element
  5. @XmlTransient: Annotate fields that we don’t want to be included in XML

Sample XML Structure

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<EmployeeDetails>
    <firstName>Vibha</firstName>
    <lastName>Singh</lastName>
    <gender>female</gender>
    <age>30</age>
    <maritalStatus>married</maritalStatus>
    <designation>Manager</designation>
    <contactNumber>+919999988822</contactNumber>
    <emailId>abc@test.com</emailId>
    <GrossSalary>75000.0</GrossSalary>
</EmployeeDetails>

Marshalling

Marshalling provides a client application the ability to convert a JAXB derived Java object tree into XML data.

Let’s see the steps to convert Java Objects into XML document.

  1. Create POJO Class of XML
  2. Create the JAXBContext object
  3. Create the Marshaller objects
  4. Create the content tree by using set methods
  5. Call the marshal method

Now, let us create the Java Objects (POJO).

import jakarta.xml.bind.annotation.*;

@XmlRootElement(name = "EmployeeDetails")
@XmlAccessorType(XmlAccessType.FIELD)

//Define the order in which the fields are written in XML
@XmlType(propOrder = { "firstName", "lastName", "gender", "age", "maritalStatus", "designation", "contactNumber",
		"emailId", "salary" })

public class Employee {

	private String firstName;
	private String lastName;
	private int age;

    @XmlElement(name = "GrossSalary")
	private double salary;
	private String designation;
	private String contactNumber;
	private String emailId;
	private String gender;
	private String maritalStatus;

	// Getter and setter methods
	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String getDesignation() {
		return designation;
	}

	public void setDesignation(String designation) {
		this.designation = designation;
	}

	public String getContactNumber() {
		return contactNumber;
	}

	public void setContactNumber(String contactNumber) {
		this.contactNumber = contactNumber;
	}

	public String getEmailId() {
		return emailId;
	}

	public void setEmailId(String emailId) {
		this.emailId = emailId;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public String getMaritalStatus() {
		return maritalStatus;
	}

	public void setMaritalStatus(String maritalStatus) {
		this.maritalStatus = maritalStatus;
	}

   @Override
	public String toString() {
		return "Employee [FirstName=" + firstName + ", LastName=" + lastName + ", Age=" + age + ", Salary=" + salary
				+ ", Designation=" + designation + ", ContactNumber=" + contactNumber + ", EmailId=" + emailId
				+ ", Gender=" + gender + ", MaritalStatus=" + maritalStatus + "]";
	}
}

Create the following test program for writing the XML file.

import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import jakarta.xml.bind.Marshaller;
import jakarta.xml.bind.PropertyException;
import org.junit.Test;
import java.io.StringWriter;

public class SerializationDemo {

    @Test
    public void serializationTest1() {

        try {

            Employee employee = new Employee();

            employee.setFirstName("Terry");
            employee.setLastName("Mathew");
            employee.setAge(30);
            employee.setSalary(75000);
            employee.setDesignation("Manager");
            employee.setContactNumber("+919999988822");
            employee.setEmailId("abc@test.com");
            employee.setMaritalStatus("married");
            employee.setGender("female");

            // Create JAXB Context
            JAXBContext context = JAXBContext.newInstance(Employee.class);

            // Create Marshaller
            Marshaller jaxbMarshaller = context.createMarshaller();

            // Required formatting
            jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

            // Write XML to StringWriter
            StringWriter sw = new StringWriter();
            jaxbMarshaller.marshal(employee, sw);

            // Convert XML to String
            String xmlContent = sw.toString();
            System.out.println(xmlContent);

        } catch (PropertyException e) {
            e.printStackTrace();

        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

When we run the code above, we may check the console output to verify that we have successfully converted Java object to XML:

By default, the Marshaller uses UTF-8 encoding when generating XML data.

The javax.xml.bind.JAXBContext class provides a client’s entry point to JAXB API. By default, JAXB does not format the XML document. This saves space and prevents that any white-space may accidentally be interpreted as significant.

To have JAXB format the output, we simply set the Marshaller.JAXB_FORMATTED_OUTPUT property to true on the Marshaller. The marshal method uses an object and an output file where to store the generated XML as parameters.

You can see that we have used JAXB Annotations like @XMLRootElement are changed from Employee to EmployeeDetails.

The order of elements in the XML is defined by

@XmlType(propOrder = { "firstName", "lastName", "gender", "age", "maritalStatus", "designation", "contactNumber","emailId", "salary" })

@XMLElement has set the element name to GrossSalary from Salary.

The below example is the short way of writing the same test and saving XML. We need to add a constructor in the POJO class so that we can set the values to the variables through the Constructor.

import jakarta.xml.bind.annotation.*;

@XmlRootElement(name = "EmployeeDetails")
@XmlAccessorType(XmlAccessType.FIELD)

//Define the order in which the fields are written in XML
@XmlType(propOrder = { "firstName", "lastName", "gender", "age", "maritalStatus", "designation", "contactNumber",
        "emailId", "salary" })

public class Employee {

    private String firstName;
    private String lastName;
    private int age;

    @XmlElement(name = "GrossSalary")
    private double salary;
    private String designation;
    private String contactNumber;
    private String emailId;
    private String gender;
    private String maritalStatus;

    public Employee() {
        super();

    }

    public Employee(String firstName, String lastName, int age, double salary, String designation, String contactNumber,
                    String emailId, String gender, String maritalStatus) {

        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;


        this.salary = salary;

        this.designation = designation;
        this.contactNumber = contactNumber;
        this.emailId = emailId;
        this.gender = gender;
        this.maritalStatus = maritalStatus;
    }

    // Getter and setter methods
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getDesignation() {
        return designation;
    }

    public void setDesignation(String designation) {
        this.designation = designation;
    }

    public String getContactNumber() {
        return contactNumber;
    }

    public void setContactNumber(String contactNumber) {
        this.contactNumber = contactNumber;
    }

    public String getEmailId() {
        return emailId;
    }

    public void setEmailId(String emailId) {
        this.emailId = emailId;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getMaritalStatus() {
        return maritalStatus;
    }

    public void setMaritalStatus(String maritalStatus) {
        this.maritalStatus = maritalStatus;
    }

    @Override
    public String toString() {
        return "Employee [FirstName=" + firstName + ", LastName=" + lastName + ", Age=" + age + ", Salary=" + salary
                + ", Designation=" + designation + ", ContactNumber=" + contactNumber + ", EmailId=" + emailId
                + ", Gender=" + gender + ", MaritalStatus=" + maritalStatus + "]";
    }
}

The below JAXB example for XML marshalling convert Java objects into an XML.

import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import jakarta.xml.bind.Marshaller;
import jakarta.xml.bind.PropertyException;
import org.junit.Test;
import java.io.File;
import java.io.StringWriter;

public class SerializationDemo {


    @Test
    public void serializationTest2() {

        try {

            Employee employee = new Employee("Thomas", "Pawsey", 35, 100000, "Director", "+919999988822","Test@test.com", "married", "female");

            // Create JAXB Context
            JAXBContext context = JAXBContext.newInstance(Employee.class);

            // Create Marshaller
            Marshaller jaxbMarshaller = context.createMarshaller();

            // Required formatting
            jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

            // Write XML to StringWriter
            StringWriter writer = new StringWriter();
            jaxbMarshaller.marshal(employee, writer);

            // Convert XML to String
            String xmlContent = writer.toString();
            System.out.println(xmlContent);

            // Save the file
            String userDir = System.getProperty("user.dir");
            jaxbMarshaller.marshal(employee, new File(userDir + "\\src\\test\\resources\\JAXB_XML.xml"));
            System.out.println("File is saved");
            
        } catch (PropertyException e) {
            e.printStackTrace();

        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

When we run the code above, we may check the console output to verify that we have successfully converted Java object to XML:

The XML is saved under src/test/resources. To see this file, after the execution of the test, you need to refresh the project.

Similarly, we can unmarshal an XML to Java Objects in the next tutorial.

We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

vibssingh

How to save Log4j 2 logs in output file using YML file

HOME

In the previous tutorial, we got an introduction to Log4j 2. In this tutorial, we will create a Selenium project and implement logging using the Log4j2 YML configuration.

Table of Contents

  1. Prerequisite
  2. Dependency List
  3. Implementation Steps
    1. Create a new Maven Project
    2. Add the dependencies to the POM.xml
    3. Create the log4j2.yml configuration file
    4. Import log4j in the Selenium script
    5. Create a Logger instance
    6. Create the Test Code with Log4j
    7. Execute the test
    8. View the logs

Prerequisite

  1. Java installed
  2. Maven installed
  3. TestNG installed

Dependency List

  1. Java -17
  2. Selenium – 4.15.0
  3. TestNG – 7.8.0
  4. Maven – 3.8.1
  5. Log4j – 3.0.0-alpha1

To use Log4j with YAML configuration, we need to add log4j-core and jackson-databind-yml dependencies to the project.

 <!-- Log4j Dependency -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>3.0.0-alpha1</version>
    </dependency>

<!-- Jackson Dataformat YAML -->
    <dependency>
      <groupId>com.fasterxml.jackson.dataformat</groupId>
      <artifactId>jackson-dataformat-yaml</artifactId>
      <version>2.16.0</version>
    </dependency>

Implementation Steps

Step 1 – Create a new Maven Project

You can use any IDE or text editor that supports Java.

Step 2- Add the dependencies to the POM.xml

Add the log4j library to your project.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>
  <artifactId>Log4j2_Demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>Log4j2_Demo</name>
  <url>http://maven.apache.org</url>

  <properties>
    <selenium.version>4.15.0</selenium.version>
    <testng.version>7.8.0</testng.version>
    <log4j.version>3.0.0-alpha1</log4j.version>
    <jackson.version>2.16.0</jackson.version>
    <maven.compiler.version>3.11.0</maven.compiler.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.surefire.failsafe.version>3.1.2</maven.surefire.failsafe.version>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
  </properties>

  <dependencies>

    <!-- TestNG Dependency -->
    <dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>${testng.version}</version>
      <scope>test</scope>
    </dependency>


    <!-- Log4j Dependency -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>${log4j.version}</version>
    </dependency>

    <!-- Selenium Dependency -->
    <dependency>
      <groupId>org.seleniumhq.selenium</groupId>
      <artifactId>selenium-java</artifactId>
      <version>${selenium.version}</version>
    </dependency>

    <!-- Jackson Dataformat YAML -->
    <dependency>
      <groupId>com.fasterxml.jackson.dataformat</groupId>
      <artifactId>jackson-dataformat-yaml</artifactId>
      <version>${jackson.version}</version>
    </dependency>


  </dependencies>

  <build>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${maven.surefire.failsafe.version}</version>
        <configuration>
          <skipTests>false</skipTests>
          <skip>false</skip>
          <testFailureIgnore>true</testFailureIgnore>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.version}</version>
        <configuration>
          <source>${maven.compiler.source}</source>
          <target>${maven.compiler.target}</target>
          <fork>true</fork>
        </configuration>
      </plugin>
    </plugins>

  </build>

</project>

Step 3- Create the log4j2.yml configuration file

Create a resource folder in src/java named as resources.

Now, create a file – log4j2.yml under the src/test/resources directory.

The log4j configuration file specifies how log4j should log information. Here is an example of a simple log4j configuration file:

Configuration:
  status: warn

  appenders:
    Console:
      name: LogToConsole
      PatternLayout:
        Pattern: "[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n"

    File:
      name: File
      fileName: logs/app.log
      PatternLayout:
      Pattern: "%d %p %C{1.} [%t] %m%n"


  Loggers:
    logger:
      - name: com.example
        level: debug
        additivity: false
        AppenderRef:
          - ref: LogToConsole
          - ref: File

    Root:
      level: error
      AppenderRef:
        ref: LogToConsole

  • We’ve defined the level of the root logger as DEBUG. This means that we’ll get all the log events with level DEBUG and above. We’ve also defined a name for the appender as LogToConsole and File.
  • We want to direct the logs to the console as well as File, we assigned the Appender type as Console and File.
  • We specify the pattern in which we want to print the log messages.

Step 4 – Import log4j in the Selenium script

We need to import the log4j library in the Selenium script, so that we can use it in your code. Here is an example of how to import log4j in the Selenium script:

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

Step 5 – Create a Logger instance

We need to create a Logger instance in the Selenium script so that we can use it to log information. Here is an example of how to create a Logger instance:

private static Logger logger = LogManager.getLogger();

Step 6 – Create the Test Code with Log4j

Here is a complete code example that demonstrates how to use log4j in Selenium:

package com.example;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import java.util.concurrent.TimeUnit;

public class Log4j_XML_Example {

    WebDriver driver;

    By userName = By.name("username");
    By passWord = By.name("password");
    By loginBtn = By.xpath("//*[@id='app']/div[1]/div/div[1]/div/div[2]/div[2]/form/div[3]/button");
    By loginTitle = By.xpath("//*[@id='app']/div[1]/div/div[1]/div/div[2]/h5");
    By dashboardPage = By.xpath("//*[@id='app']/div[1]/div[1]/header/div[1]/div[1]/span/h6");
    By actualErrorMessage =  By.xpath("//*[@class='orangehrm-login-error']/div[1]/div[1]/p");

    // Creating a logger
    private static Logger logger = LogManager.getLogger();

    @BeforeMethod
    public void setUp() {

        logger.info("Open a Chrome Web Browser");
        ChromeOptions options=new ChromeOptions();

        logger.info("Make the Web Browser full screen");
        options.addArguments("--start-maximized");
        driver=new ChromeDriver(options);

        logger.info("Wait for 10 sec");
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://opensource-demo.orangehrmlive.com/");
        logger.info("Open the application");
    }

    @Test(description = "This test validates title of login functionality", priority = 0)
    public void verifyLoginPageTitle() {

        logger.info("Verify the Login page title");
        String expectedTitle = driver.findElement(loginTitle).getText();

        logger.info("Expected Title :" + expectedTitle);
        Assert.assertTrue(expectedTitle.equalsIgnoreCase("Login"));
    }

    @Test(description = "This test validates successful login to Home page", priority = 1)
    public void verifyloginPage() {

        logger.info("Enter Username");
        driver.findElement(userName).sendKeys("Admin");

        logger.info("Enter Password");
        driver.findElement(passWord).sendKeys("admin123");

        driver.findElement(loginBtn).submit();
        logger.info("New page - Dashboard is opened");
        String newPageText = driver.findElement(dashboardPage).getText();

        logger.info("Heading of new page :" + newPageText);
        Assert.assertTrue(newPageText.contains("Dashboard"));

    }

    @Test(description = "This test validates unsuccessful login", priority = 2)
    public void verifyIncorrectCredentials() {

        logger.info("Enter Username");
        driver.findElement(userName).sendKeys("12345");

        logger.info("Enter Password");
        driver.findElement(passWord).sendKeys("admin123");

        driver.findElement(loginBtn).submit();
        logger.info("Error Message is displayed");
        String ErrorMessage = driver.findElement(actualErrorMessage).getText();

        logger.info("Error Message :" + ErrorMessage);
        Assert.assertEquals(ErrorMessage, "Invalid credentials");
    }

    @AfterMethod
    public void teardown() {

        logger.info("Close the webpage");
        driver.quit();
    }

}

Step 7 – Execute the test

Right-click on the test and select “Run Log4j_XML_Example”.

The output of the above program is

Step 8 – View the logs

The log is printed as specified in the log4j2.yml file. The timestamp is specified in PatternLayout. The log type is INFO.

The output log file is created under folder logs that are created at the root level of the project. The file name is app.log.

The app.log file will look like the image shown below.

If you want to add RollingFile details in the file, you can refer to the below file for the same.

    RollingFile:
      - name: LogToRollingFile
        fileName: logs/app.log
        filePattern: "logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz"
        PatternLayout:
          pattern: "[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n"
        Policies:
          SizeBasedTriggeringPolicy:
            size: 1KB
        DefaultRollOverStrategy:
          max: 5

Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!