jaxp/test/javax/xml/jaxp/unittest/validation/Bug6773084Test.java
changeset 40292 bcb68f9b7b34
parent 40223 64662417aa2d
child 40829 ad509d5baa06
equal deleted inserted replaced
40291:c0ab22b640c9 40292:bcb68f9b7b34
    30 import java.io.IOException;
    30 import java.io.IOException;
    31 import java.util.concurrent.BrokenBarrierException;
    31 import java.util.concurrent.BrokenBarrierException;
    32 import java.util.concurrent.CyclicBarrier;
    32 import java.util.concurrent.CyclicBarrier;
    33 import java.util.concurrent.ExecutorService;
    33 import java.util.concurrent.ExecutorService;
    34 import java.util.concurrent.Executors;
    34 import java.util.concurrent.Executors;
       
    35 import java.util.concurrent.TimeUnit;
    35 
    36 
    36 import javax.xml.XMLConstants;
    37 import javax.xml.XMLConstants;
    37 import javax.xml.parsers.DocumentBuilder;
       
    38 import javax.xml.parsers.DocumentBuilderFactory;
    38 import javax.xml.parsers.DocumentBuilderFactory;
    39 import javax.xml.parsers.ParserConfigurationException;
       
    40 import javax.xml.transform.Source;
    39 import javax.xml.transform.Source;
    41 import javax.xml.transform.dom.DOMSource;
    40 import javax.xml.transform.dom.DOMSource;
    42 import javax.xml.transform.stream.StreamSource;
    41 import javax.xml.transform.stream.StreamSource;
    43 import javax.xml.validation.Schema;
    42 import javax.xml.validation.Schema;
    44 import javax.xml.validation.SchemaFactory;
    43 import javax.xml.validation.SchemaFactory;
    67 
    66 
    68     private static final int NTHREADS = 25;
    67     private static final int NTHREADS = 25;
    69     private static final ExecutorService EXEC = Executors.newCachedThreadPool();
    68     private static final ExecutorService EXEC = Executors.newCachedThreadPool();
    70 
    69 
    71     private static final CyclicBarrier BARRIER = new CyclicBarrier(NTHREADS);
    70     private static final CyclicBarrier BARRIER = new CyclicBarrier(NTHREADS);
       
    71     private static final int TIMEOUT = 110;
    72 
    72 
    73     public static final String IN_FOLDER = Bug6773084Test.class.getResource("Bug6773084In").getPath();
    73     public static final String IN_FOLDER = Bug6773084Test.class.getResource("Bug6773084In").getPath();
    74     public static final String XSD_PATH = Bug6773084Test.class.getResource("Bug6773084.xsd").getPath();
    74     public static final String XSD_PATH = Bug6773084Test.class.getResource("Bug6773084.xsd").getPath();
    75 
    75 
    76     private static Schema schema;
    76     private static Schema schema;
    91             public boolean accept(File file) {
    91             public boolean accept(File file) {
    92                 return file.isFile() && file.getName().endsWith(".xml");
    92                 return file.isFile() && file.getName().endsWith(".xml");
    93             }
    93             }
    94         });
    94         });
    95 
    95 
       
    96         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
       
    97         dbf.setNamespaceAware(true);
       
    98 
    96         for (int i = 0; i < files.length; i++) {
    99         for (int i = 0; i < files.length; i++) {
    97             EXEC.execute(new XMLValiddator(files[i], i));
   100             EXEC.execute(new XMLValiddator(dbf.newDocumentBuilder().parse(files[i]), i));
    98         }
   101         }
    99         runWithAllPerm(() -> EXEC.shutdown());
   102         runWithAllPerm(() -> EXEC.shutdown());
   100 
   103         EXEC.awaitTermination(TIMEOUT, TimeUnit.SECONDS);
   101     }
   104     }
   102 
   105 
   103     private static class XMLValiddator implements Runnable {
   106     private static class XMLValiddator implements Runnable {
   104 
   107 
   105         private File file;
   108         private Document document;
   106         private int index;
   109         private int index;
   107 
   110 
   108         public XMLValiddator(File file, int index) {
   111         public XMLValiddator(Document document, int index) {
   109             this.file = file;
   112             this.document = document;
   110             this.index = index;
   113             this.index = index;
   111         }
   114         }
   112 
   115 
   113         public void run() {
   116         public void run() {
   114 
   117 
   115             try {
   118             try {
   116                 System.out.printf("Waiting for barrier: %s%n", index);
   119                 System.out.printf("Waiting for barrier: %s%n", index);
   117                 BARRIER.await();
   120                 BARRIER.await();
   118                 System.out.println("Validating....");
   121                 System.out.println("Validating....");
   119 
   122 
   120                 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
       
   121                 factory.setNamespaceAware(true);
       
   122 
       
   123                 DocumentBuilder builder = factory.newDocumentBuilder();
       
   124                 Document document = builder.parse(file);
       
   125 
       
   126                 Validator validator = schema.newValidator();
   123                 Validator validator = schema.newValidator();
   127                 validator.setErrorHandler(new ErrorHandlerImpl());
   124                 validator.setErrorHandler(new ErrorHandlerImpl());
   128                 validator.validate(new DOMSource(document));
   125                 validator.validate(new DOMSource(document));
   129 
       
   130             } catch (IOException e) {
   126             } catch (IOException e) {
   131                 e.printStackTrace();
   127                 e.printStackTrace();
   132             } catch (SAXException e) {
   128             } catch (SAXException e) {
   133                 e.printStackTrace();
   129                 e.printStackTrace();
   134                 Assert.fail("Test failed.");
   130                 Assert.fail("Test failed.");
   135             } catch (ParserConfigurationException e) {
       
   136                 e.printStackTrace();
       
   137             } catch (BrokenBarrierException e) {
   131             } catch (BrokenBarrierException e) {
   138                 e.printStackTrace();
   132                 e.printStackTrace();
   139             } catch (InterruptedException e) {
   133             } catch (InterruptedException e) {
   140                 e.printStackTrace();
   134                 e.printStackTrace();
   141             }
   135             }