static {
        StackTraceUtils.addClassTest({ String className ->
            if (className.startsWith("org.spockframework.")) return false;
            return null;
        });
    }

import org.codehaus.groovy.runtime.StackTraceUtils;
public class MyException extends RuntimeException {
    public MyException(String message, Object... suppressed) {
        super(message);
        for (Object t : suppressed)
            if (t instanceof Throwable) this.addSuppressed(StackTraceUtils.deepSanitize((Throwable) t));
        StackTraceUtils.deepSanitize(this);
    }
}

import scala.io.Source
import scala.util.parsing.json._

object JsonComparator {
  def compare(left: Any, right: Any, path: java.lang.String = ""): List[String] = (left, right) match {
    case (l: Number, r: Number) => if (l == r) Nil else s"$path: $l != $r" :: Nil
    case (l: String, r: String) => if (l == r) Nil else s"$path: $l != $r" :: Nil
    case (l: Set[_], r: Set[_]) => if (l == r) Nil else s"$path: $l != $r" :: Nil
    case (l: List[_], r: List[_]) =>
      if (l == r) Nil
      else if (l.length != r.length) s"$path.length: ${l.length} vs. ${r.length}" :: Nil
      else l.indices.toList.filter(it => l(it) != r(it)).flatMap(it => compare(l(it), r(it), s"$path[$it]"))
    case (l: Map[String, _], r: Map[String, _]) =>
      if (l == r) Nil
      else if (l.size != r.size) s"$path.count: ${l.size} != ${r.size}" :: Nil
      else if (l.keySet != r.keySet) s"$path.keys: ${l.keySet} != ${r.keySet}" :: Nil
      else l.keySet.toList.filter(it => l(it) != r(it)).flatMap(it => compare(l(it), r(it), s"$path/$it"))
    case _ =>
      s"$path: $left[${if (left == null) left else left.getClass}] vs. $right[${if (right == null) right else right.getClass}]" :: Nil
  }

  def main(args: Array[java.lang.String]): Unit = {
    val left = JSON.parseFull(Source.fromResource("left.json").mkString)
    val right = JSON.parseFull(Source.fromResource("right.json").mkString)
    compare(left.get, right.get).foreach(println)
    compare(left.get, left.get).foreach(println)
  }
}

{"node1": [1, 2, ["q","w"], "e"], "node2": {"node3": "value4","null": null}, "node3": 3, "node4": 4, "node5": 5.5}

{"node1": [1, "3", ["q", "w", 0], "e"], "node2": {"node3": "value4", "null": "null"}, "node3": "3", "node4": 4, "node5": 5.6}

/node1[1]: 2.0[class java.lang.Double] vs. 3[class java.lang.String]
/node1[2].length: 2 vs. 3
/node3: 3.0[class java.lang.Double] vs. 3[class java.lang.String]
/node2/null: null[null] vs. null[class java.lang.String]
/node5: 5.5 != 5.6

function filterNodes(jQuerySet,value){
	let strContainsAnyOf=(haystack,needle)=>!needle.every(it=>haystack.indexOf(it)<0)
	var count=0;
	value=String(value).toUpperCase();
	var values=value.split(" ").map(it=>unescape(it)).filter(it=>it!='').filter(it=>it!='!');
	let expectations={}
	for(let value of values)
		(value[0]=='!')?(expectations[value.substr(1)]=false):expectations[value]=true;
	for(let node of jQuerySet.toArray()){
		var nodeValue=(''+node.innerHTML).toUpperCase().replace(/<[^>]+>/g, '');
		var visible=true;
		for(let value in expectations)
			if(expectations[value]!=strContainsAnyOf(nodeValue,value.split("|")))visible=false;
		$(node)[['hide','show'][1&visible]]();
		count+=visible;
	}
	return count;
}

window[Symbol.for('d1702070851-LESS loaded')]||addResource("//cdnjs.cloudflare.com/ajax/libs/less.js/2.5.1/less.min.js","js");
	window[Symbol.for('d1702070851-LESS loaded')]=true;

function createNode(nodeName,attributes){
	var node=document.createElement(nodeName);
	for(var k in attributes)
		node.setAttribute(k,attributes[k]);
	document.getElementsByTagName('head')[0].appendChild(node);
}
function addResource(path,extension){
	if(extension=='css')return createNode('link',{rel:'stylesheet',type:'text/css',href:path});
	if(extension=='js')return createNode('script',{src:path});
	if(extension=='less')return createNode('link',{rel:'stylesheet',type:'text/less',href:path});
	throw "Extension not supported: "+extension;
}

addResource('https://w01bagdc/chromeExtension/<%domain%>.less','less');
addResource("//cdnjs.cloudflare.com/ajax/libs/less.js/2.5.1/less.min.js","js");

function selectText(element) {
    var selection = window.getSelection();
    var range = document.createRange();
    range.selectNodeContents(element);
    selection.removeAllRanges();
    selection.addRange(range);
}

set path=%path%;"c:\Program Files\Java\<jdk>\bin"
keytool -genkey -keyalg RSA -alias <host> -keystore <host>.jks -storepass <host> -validity 360 -keysize 2048 -ext SAN=dns:<host>
keytool -v -export -file <host>.cer -keystore <host>.jks -alias <host>

InetSocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(), port);
com.sun.net.httpserver.HttpsServer httpsServer = com.sun.net.httpserver.HttpsServer.create(address, 0);
SSLContext sslContext = SSLContext.getInstance("TLS");
char[] password = "<host>".toCharArray();
KeyStore ks = KeyStore.getInstance("JKS");
// keytool -genkey -keyalg RSA -alias HOSTNAME -keystore HOSTNAME.jks -storepass HOSTNAME -validity 360 -keysize 2048 -ext SAN=dns:<host>
// keytool -v -export -file HOSTNAME.cer -keystore HOSTNAME.jks -alias HOSTNAME
FileInputStream fis = new FileInputStream("c:\\<path>\\<host>.jks");
ks.load(fis, password);
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
kmf.init(ks, "<host>".toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(ks);
sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
httpsServer.setHttpsConfigurator(new HttpsConfigurator(sslContext) {
	public void configure(HttpsParameters params) {
		try {
			SSLContext c = SSLContext.getDefault();
			SSLEngine engine = c.createSSLEngine();
			params.setNeedClientAuth(false);
			params.setCipherSuites(engine.getEnabledCipherSuites());
			params.setProtocols(engine.getEnabledProtocols());
			SSLParameters defaultSSLParameters = c.getDefaultSSLParameters();
			params.setSSLParameters(defaultSSLParameters);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
});
HttpHandler handler = new HttpHandler(""+port);
httpsServer.createContext("/", handler);
ExecutorService executor = Executors.newFixedThreadPool(50);
httpsServer.setExecutor(executor);
httpsServer.start();

package eu.sorescu.junit;

import org.junit.runner.Runner;
import org.junit.runners.Parameterized;
import org.junit.runners.parameterized.BlockJUnit4ClassRunnerWithParametersFactory;
import org.junit.runners.parameterized.ParametersRunnerFactory;
import org.junit.runners.parameterized.TestWithParameters;

import java.util.*;
import java.util.stream.Collectors;

import org.junit.runners.model.FrameworkMethod;

public class SorescuParameterized extends Parameterized {

    @SuppressWarnings("unused")
    public SorescuParameterized(Class<?> klass) throws Throwable {
        this(klass, 0, null, klass.getSimpleName());
    }

    public String getName() {
        return this.name;
    }

    private final String name;

    public SorescuParameterized(Class<?> klass, final int depth, List<TestData> subset, String name) throws Throwable {
        super(klass);
        this.name = System.identityHashCode(this) + "." + name + "a.b.c.d" + "." + name;
        if (subset == null) subset = (List<TestData>) this.getParametersMethod().invokeExplosively(null);
        if (depth >= 3) {
            runners = Collections.unmodifiableList(createRunnersForParameters(subset));
        } else {
            runners = new ArrayList<>();
            HashMap<Object, List<TestData>> hashParameters = new HashMap<>();
            for (TestData vector : subset) {
                String key = String.valueOf(vector.segments.get(depth));
                if (!hashParameters.containsKey(key))
                    hashParameters.put(key, new ArrayList<>());
                hashParameters.get(key).add(vector);
            }
            try {
                for (Object key : hashParameters.keySet())
                    runners.add(new SorescuParameterized(klass, depth + 1, hashParameters.get(key), String.valueOf(key)));
            } catch (Throwable throwable) {
                throw new RuntimeException(throwable);
            }
        }
    }

    private static final ParametersRunnerFactory DEFAULT_FACTORY = new BlockJUnit4ClassRunnerWithParametersFactory();
    private final List<Runner> runners;

    protected List<Runner> getChildren() {
        return this.runners;
    }

    private FrameworkMethod getParametersMethod() throws Exception {
        List<FrameworkMethod> methods = this.getTestClass().getAnnotatedMethods(Parameterized.Parameters.class);
        Optional<FrameworkMethod> method = methods.stream().filter(it -> it.isStatic() && it.isPublic()).findAny();
        return method.orElseThrow(() -> new Exception("No public static parameters method on class " + this.getTestClass().getName()));
    }

    private List<Runner> createRunnersForParameters(List<TestData> allParameters) throws Exception {
        ArrayList<Runner> runners = new ArrayList<>();
        for (Object test : this.createTestsForParameters(allParameters))
            runners.add(DEFAULT_FACTORY.createRunnerForTestWithParameters((TestWithParameters) test));
        return runners;
    }

    private List<TestWithParameters> createTestsForParameters(List<TestData> allParameters) throws Exception {
        int i = 0;
        ArrayList<TestWithParameters> children = new ArrayList<>();
        for (TestData parametersOfSingleTest : allParameters) {
            children.add(_createTestWithParameters(this.getTestClass(), ++i, parametersOfSingleTest));
        }
        return children;
    }

    private TestWithParameters _createTestWithParameters(org.junit.runners.model.TestClass testClass, int index, TestData parameters) {
        String name = "" + index + "." + parameters.segments.stream().map(String::valueOf).collect(Collectors.joining());
        return new TestWithParameters("[" + name + "]", testClass, Collections.singletonList(parameters));
    }
}

package eu.sorescu.junit;

import java.util.ArrayList;
import java.util.List;

public class TestData {
    List<Object>segments;
    public TestData(Object[] segments) {
        this.segments = new ArrayList();
        for (Object s : segments)
            this.segments.add(s);
    }

    public List<Object> getSegments() {
        return segments;
    }
}

package eu.sorescu.junit

import groovy.transform.CompileStatic
import groovy.transform.TypeChecked
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.Parameterized

@RunWith(SorescuParameterized)
@TypeChecked @CompileStatic
public class TestClass {
    private  TestData td;
    public TestClass(TestData td){
        this.td=td;
    }
    @Parameterized.Parameters(name='{index} {0} {1}')
    public static List<Object[]> data() {
        def a=[]
        for(def i=0;i<9;i++) {
            a.add(new TestData(i, i + 1, i + 2,i+4))
            a.add(new TestData(i, i + 1, i + 3,i+4))
            a.add(new TestData(i, i + 2, i + 4,i+4))
        }
        return a
    }

    @Test
    public void f1() {
        if(td.segments.get(1).equals(2))throw new RuntimeException("EEE"+td.segments.get(1));
        println "testRun f1 "+td.segments
    }
    @Test
    public void f2() {
        println "testRun f2 "+td.segments
    }
}

package eu.sorescu

import groovy.transform.Memoized
import org.xml.sax.SAXException;

import javax.xml.parsers.ParserConfigurationException;
import java.util.zip.ZipFile;

class XlsxReader {
    ZipFile zf;

    public XlsxReader(File file) { this.zf = new ZipFile(file); }

    public Node getXml(String path) throws IOException, ParserConfigurationException, SAXException {
        new XmlParser(false, false).parse(zf.getInputStream(zf.getEntry(path)))
    }

    @Memoized
    public String[] getSharedStrings() {
        return this.getXml("xl/sharedStrings.xml").si*.t*.text()
    }

    public ArrayList<String> getSheetNames() throws IOException {
        return this.getXml("xl/workbook.xml").sheets.sheet*.'@name'
    }

    @Memoized
    public static int[] l2c(String l) {
        String letters = l.replaceAll(/\d+/, '')
        int row = (l.replaceAll(/[^\d]+/, '') as int) - 1
        if (letters.length() == 1) return [row, letters.codePointAt(0) - 65];
        if (letters.length() == 2) return [row, (letters.codePointAt(1) - 64) * 26 + (letters.codePointAt(0) - 65)]
        throw new RuntimeException("Not supported: " + letters)
    }

    public List<List<String>> getSheet(String sheetName) {
        def rid = this.getXml("xl/workbook.xml").sheets.sheet.find { it.'@name' == sheetName }.'@r:id'
        String sheetPath = this.getXml("xl/_rels/workbook.xml.rels").Relationship.find { it.'@Id' == rid }.'@Target'
        List<List<String>> result = new ArrayList<>();
        def res = this.getXml('xl/' + sheetPath)
        res.sheetData.row.each { row ->
            row.c.each { c ->
                if (c.v) {
                    int[] coordinates = l2c(c.'@r' as String)
                    String value = c.v.text()
                    if (c.'@t' == 's') value = sharedStrings[value as int]
                    try {
                        if (!result[coordinates[0]]) result[coordinates[0]] = []
                        result[coordinates[0]][coordinates[1]] = String.valueOf(value).intern()
                    } catch (Throwable ignored) {
                        println sheetName + " " + sheetPath + " " + coord + " " + value
                    }
                }
            }
        }
        for (int i = 0; i < result.size(); i++)
            result[i] = result[i] ?: []
        return result
    }
}