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
    }
}

def binaryCoverage={list->
	int listLength=list.size()
	int bitSize=32-Integer.numberOfLeadingZeros(listLength)
	return (0..<bitSize).collect{bit->(0..<listLength).findAll{!(it&(1<<bit))}.collect{list[it]}}
}

def list=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
assert binaryCoverage(list)==[[0, 2, 4, 6, 8, 10, 12, 14], [0, 1, 4, 5, 8, 9, 12, 13], [0, 1, 2, 3, 8, 9, 10, 11], [0, 1, 2, 3, 4, 5, 6, 7]]

#!/usr/bin/python
import BaseHTTPServer
import SimpleHTTPServer
import cgi
import os
import Cookie
import re
server=BaseHTTPServer.HTTPServer

open("http.lock", "w")

def executeTemplate(templatePath,context):
	template=open(templatePath,'r').read()
	template=template.replace('\r','')
	variables={}
	variables['__context']=context
	code=[]
	if(templatePath.endswith(".pyp")):
		for pair in template.split('?>'):
			pair=pair.split('<?')
			if(len(pair[0])>0):
				indent=re.split('[^\\s]',pair[0][1:])[0]
				variables[len(variables)]=pair[0]
				code.append("\n"+indent+"println(variables[{0}].format(**locals()))".format((len(variables)-1)))
			if(len(pair)>1):
				if(pair[1][0]=='='):pair[1]="\n"+re.split('[^\\s]',pair[1][1:])[0]+"println("+pair[1][1:]+")"
				if(pair[1][0]=='<'):pair[1]="\n"+re.split('[^\\s]',pair[1][1:])[0]+"__executeTemplate(('"+pair[1][1:len(pair[1])-1]+"',variables['__context']))"
				code.append(pair[1])
	else:
		code.append(template)
	locals={}
	locals['variables']=variables
	print(code)
	exec(''.join(code))in context,locals
class CustomHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
	def do_GET(self):
		print("http {0} {1}".format(self.path,os.path.exists("."+self.path)))
		if(os.path.exists("."+self.path)and(self.path<>'/')):
			return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
		else:
			context={}
			context['response']={}
			context['response']['code']=200
			context['response']['headers']={}
			context['response']['headers']["Content-type"]="text/html"
			context['self']=self
			context['println']=lambda x: self.wfile.write(x)
			context['cookie']=None
			context['__executeTemplate']=lambda(a,b):executeTemplate(a,b)
			context['scriptPath']='.'+self.path.split("?")[0]
			if "Cookie" in self.headers:
				context['cookie']=Cookie.SimpleCookie(self.headers["Cookie"])['value'].value
			exec(open('http/__before__.py', 'r').read())in context
			self.send_response(context['response']['code'])
			if context['cookie']:
				c=Cookie.SimpleCookie()
				c['value']=context['cookie']
				context['response']['headers']['Set-Cookie']=c.output(header='')
			for key,value in context['response']['headers'].iteritems():
				self.send_header(key,value)
			self.end_headers()
			try:
				executeTemplate(context['scriptPath'],context)
			except Exception as inst:
				self.wfile.write("</pre></script></textarea></script><pre style='color:red'>"+cgi.escape(inst.__repr__(),True)+"</pre><a href='/'>Back home</a>")
				#sys.stderr.write(exp1.__repr__()+"\r\n")
				#traceback.print_exc()
				print(inst)

handler=CustomHTTPRequestHandler
httpd=server(("", 3187), handler)
httpd.serve_forever()

import cv2,os,os.path
def archiveFolder(folderPath):
    fourcc = cv2.VideoWriter_fourcc(*'MJPG')#XVID
    if os.path.exists(folderPath+".avi"): os.remove(folderPath+'.avi')
    out = cv2.VideoWriter(folderPath+'.avi',fourcc,20,(320,200))
    for fileName in os.listdir(folderPath):
        if fileName.endswith(".txt"):continue
        if fileName.endswith(".db"):continue
        if not fileName.endswith('.jpg'):raise Exception(fileName)
        filePath=folderPath+"\\"+fileName
        img=cv2.imread(filePath)
        img= cv2.resize(img, (320, 200))
        font = cv2.FONT_HERSHEY_PLAIN
        cv2.putText(img,fileName,(0,20), font, 1,(0,128,255),1)
        print fileName
        out.write(img)
    print "Releasing..."
    out.release()

import groovy.transform.TypeChecked

import javax.swing.JButton
import javax.swing.JDialog
import javax.swing.JFrame
import javax.swing.JScrollPane
import javax.swing.JTable
import javax.swing.JTextField
import javax.swing.RowFilter
import javax.swing.event.ListSelectionListener
import javax.swing.table.AbstractTableModel
import javax.swing.table.TableModel
import javax.swing.table.TableRowSorter
import java.awt.BorderLayout
import java.awt.Dialog
import java.awt.Dimension
import java.awt.event.ActionListener
import java.awt.event.KeyListener

@TypeChecked
public class Q1 {
    public static void main(String[] args) {
        println showDialog("title", (1..100).collect { "qwe" + it }).join("; ")
    }

    public static List<String> showDialog(String title, List<String> options) {
        def selection = []
        def dialog = new JDialog(null, title, Dialog.ModalityType.TOOLKIT_MODAL);
        dialog.defaultCloseOperation = JFrame.DISPOSE_ON_CLOSE
        dialog.layout = new BorderLayout()
        def text = new JTextField()
        def button = new JButton("Select");
        TableModel dataModel = [getColumnCount: { -> 1 }, getRowCount: { -> options.size()
        }, getValueAt                         : { int row, int col -> options[row] }] as AbstractTableModel
        def table = new JTable(dataModel);

        dialog.add(text, BorderLayout.PAGE_START)
        dialog.add(button, BorderLayout.PAGE_END)
        def scroll = new JScrollPane(table)
        dialog.add(scroll, BorderLayout.CENTER)

        button.addActionListener([actionPerformed: { dialog.dispose() }] as ActionListener)

        def sorter = new TableRowSorter(dataModel);
        table.selectionModel.addListSelectionListener([valueChanged: {
            selection = (0..options.size() - 1).collect {
                table.selectionModel.isSelectedIndex(it) ? options[it] : null
            }.findAll { it != null }
            button.text = selection.size() + " selected. " + selection.join(", ")
        }] as ListSelectionListener)
        table.setRowSorter(sorter)
        text.addKeyListener([keyPressed: {}, keyTyped: {}, keyReleased: {
            sorter.setRowFilter(RowFilter.regexFilter(text.getText(), 0));
            sorter.sort()
        }] as KeyListener)
        dialog.size = dialog.preferredSize = new Dimension(200, 640)
        dialog.locationRelativeTo = null
        dialog.visible = true
        return selection
    }
}

assert orthoCover([[a:1,b:2],[a:2,b:3,c:4],[a:4,b:5],[a:2,b:2]])==[[a:2, b:3, c:4], [a:4, b:5],[a:1, b:2]]

public List cartesian(Collection... collections) {
        collections = collections.collect { collection -> collection.collect { [it] } }
        def result = collections.first()
        collections.drop(1).each { collection ->
            result = result.collect { left -> collection.collect { right -> left + right } }.sum()
        }
        return result
    }

public static string Hash(string password)
        {
            using (var deriveBytes = new Rfc2898DeriveBytes(password, 16, 1000))
            {
                return Convert.ToBase64String(new byte[1].Concat(deriveBytes.Salt).Concat(deriveBytes.GetBytes(32)).ToArray());
            }
        }

        public static bool CheckHash(string hashBase64, string password)
        {
            var hash = Convert.FromBase64String(hashBase64);
            using (var deriveBytes = new Rfc2898DeriveBytes(password, hash.Skip(1).Take(16).ToArray(), 1000))
            {
                return hash.Skip(1).Skip(16).Take(32).SequenceEqual(deriveBytes.GetBytes(32));
            }
        }