Use below steps for JSON schema validation using Rest Assured

Step 1: Copy Latest Maven dependency from below link

https://mvnrepository.com/artifact/io.rest-assured/json-schema-validator

Step 2: Get JSON Schema from developer or generate using some tool (Click Here for online Tool) from your api. Use below sample for test (save it with Sample.json):

{
  "$schema": "http://json-schema.org/draft-04/schema",
  "type": "array",
  "items": [
    {
      "type": "object",
      "properties": {
        "postId": {
          "type": "integer"
        },
        "id": {
          "type": "integer"
        },
        "name": {
          "type": "string"
        },
        "email": {
          "type": "string"
        },
        "body": {
          "type": "string"
        }
      },
      "required": [
        "postId",
        "id",
        "name",
        "email",
        "body"
      ]
    },
    {
      "type": "object",
      "properties": {
        "postId": {
          "type": "integer"
        },
        "id": {
          "type": "integer"
        },
        "name": {
          "type": "string"
        },
        "email": {
          "type": "string"
        },
        "body": {
          "type": "string"
        }
      },
      "required": [
        "postId",
        "id",
        "name",
        "email",
        "body"
      ]
    },
    {
      "type": "object",
      "properties": {
        "postId": {
          "type": "integer"
        },
        "id": {
          "type": "integer"
        },
        "name": {
          "type": "string"
        },
        "email": {
          "type": "string"
        },
        "body": {
          "type": "string"
        }
      },
      "required": [
        "postId",
        "id",
        "name",
        "email",
        "body"
      ]
    },
    {
      "type": "object",
      "properties": {
        "postId": {
          "type": "integer"
        },
        "id": {
          "type": "integer"
        },
        "name": {
          "type": "string"
        },
        "email": {
          "type": "string"
        },
        "body": {
          "type": "string"
        }
      },
      "required": [
        "postId",
        "id",
        "name",
        "email",
        "body"
      ]
    },
    {
      "type": "object",
      "properties": {
        "postId": {
          "type": "integer"
        },
        "id": {
          "type": "integer"
        },
        "name": {
          "type": "string"
        },
        "email": {
          "type": "string"
        },
        "body": {
          "type": "string"
        }
      },
      "required": [
        "postId",
        "id",
        "name",
        "email",
        "body"
      ]
    }
  ]
}

Step 3: Create Sample.java file and paste below code

import org.testng.annotations.Test;
import static io.restassured.module.jsv.JsonSchemaValidator.matchesJsonSchemaInClasspath;

import io.restassured.RestAssured;

public class Sample
{
	@Test
	
	public void testJsonSchema()
	{
		RestAssured.given()
			.when()
			.get("https://jsonplaceholder.typicode.com/comments?postId=1")
			.then()
			.assertThat()
			.body(matchesJsonSchemaInClasspath("com/mycompany/api/bl/Sample.json"));
	}
}

Here in get you have to specify your request and in body you have to specify path where your json schema file is.

Waiting for an alert to appear on a page can be performed using explicit wait in protractor.

browser.wait(ExpectedConditions.alertIsPresent(), 30000);

Text area does not have much difference from the text bar so that we can handle it like normal textbox/text bar element.

The group index is nothing but writing the XPath as a sequence. For example, XPath provides numbers from 1,2,3... for the element under every parent.

When we use an index, we might get end up having multiple elements when we wanted a particular element.

In such cases, the Group index will be more helpful to the user. Now the Group index numbers the element from 1..., even though element under the different parent.

The index numbers will never be repeated.

As of now, we can say chercher-tech-jasmine-reporter is a more suitable report for the protractor and Jasmine combination.

We need to follow a few steps to make sure that the element is selected or not, Normally when we have this kind of scenario, what we do is, we will use click() method to select the checkbox. After this, we might move on to the next step of the scenario.

Sometimes not selecting will help you; you got to make sure that the checkbox is selected. To verify it we need to use the isSelected() method and get check whether it is really selected.

Headless browser doesn’t require a graphics driver at all, They just get commands and execute them directly in memory. To achieve this, you need to specify headless in configuration.js under capabilities.

Chrome

capabilities: {
  browserName: 'chrome',

  chromeOptions: {
	 args: [ "--headless", "--disable-gpu", "--window-size=800,600" ]
   }
}

Firefox

capabilities: {
  browserName: 'firefox',

  'moz:firefoxOptions': {
	 args: [ "--headless" ]
   }
}

Use below code:

package com.test.filehandling;

import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ThreadSafeArrayList<E>
{
	private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
	private final Lock readLock = readWriteLock.readLock();
	private final Lock writeLock = readWriteLock.writeLock();
	
	private final List<E> list = new ArrayList<E>();
	
	public void set(E o)
	{
        writeLock.lock();
        try
        {
            list.add(o);
            System.out.println("Adding element by thread: "+Thread.currentThread().getName());
        }
        finally
        {
            writeLock.unlock();
        }
	}
	
	public E get(int i)
	{
		readLock.lock();
        try
        {
            System.out.println("Printing elements by thread: "+Thread.currentThread().getName());
            return list.get(i);
        }
        finally
        {
            readLock.unlock();
        }
    }
	
    public static void main(String[] args)
    {
        ThreadSafeArrayList<String> threadSafeArrayList = new ThreadSafeArrayList<String>();
        threadSafeArrayList.set("1");
        threadSafeArrayList.set("2");
        threadSafeArrayList.set("3");
 
        System.out.println("Printing the First Element: "+threadSafeArrayList.get(0));
    }
}

Below are the difference:

Example Code 1: 

public interface  A  
{	
    public void m1();
    public void m2();
}

class B implements A
{
    public void m1()
    {	
    }
}

Output: compile-time error:- The type B must implement the inherited abstract method A.m2()

Example Code 2: 

public interface A  
{
    public void m1();
    public void m2();
}

abstract class B implements A
{
    public void m1()
    {
        System.out.println("Vinay");
    }
}

class C extends B
{
    public void m2()
    {
        System.out.println("Method2 value from the class C");
    }
    public void m1()
    {
        System.out.println("Method1 value from the class C");
    }

    public static void main(String[] args)
    {
        C c=new C();
        c.m1();
        c.m2();

        B b=new C();
        b.m1();
        b.m2();

        A a=new C();
        a.m1();
        a.m2();
    }
}

Output:

Method1 value from the class C

Method2 value from the class C

Method1 value from the class C

Method2 value from the class C

Method1 value from the class C

Method2 value from the class C