На могу запустить Mockito

package validator;
 
 
import org.junit.*;
import org.junit.runner.RunWith;
 
import validator.Validator.NotValidXMLException;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
 
 
import static org.junit.Assert.*;
 
import static org.mockito.Mockito.*;
 
import java.io.FileNotFoundException;
 
 
import javax.xml.stream.XMLStreamException;
 
 
@RunWith(MockitoJUnitRunner.class)
public class ValidatorTest {
    
 
    
    private Validator validator;
    private String path = "src/validatorTest/";
 
      @InjectMocks
        Validator myValidator=new Validator();
 
        @Mock
        Validator.Buildfile buildfile;
    
     
        public void initTest() {
            myValidator.setCheckdefault(true);
            myValidator.setCheckdepends(true);
            myValidator.setChecknames(true);
            when(buildfile.getLocation()).thenReturn(path);
        }
 
    
    @Before
    public void setUp() {
        validator = new Validator();
    }
 
    @After
    public void tearDown() {
        //validator = null;
    }
    
    @Test
    public void testValidFileException() {
        
        validator.execute();
    }
 
    @Test
    public void testIsCheckdefault() {
        assertEquals(validator.isCheckdefault(), false);
    }
 
    @Test
    public void testIsCheckdepends() {
        assertEquals(validator.isCheckdepends(), false);
    }
 
    @Test
    public void testIsChecknames() {
        assertEquals(validator.isChecknames(), false);
    }
 
    @Test
    public void testSetIsCheckdefault() {
        validator.setCheckdefault(true);
        assertEquals(validator.isCheckdefault(), true);
    }
 
    @Test
    public void testSetIsCheckdepends() {
        validator.setCheckdepends(true);
        assertEquals(validator.isCheckdepends(), true);
    }
 
    @Test
    public void testSetIsChecknames() {
        validator.setChecknames(true);
        assertEquals(validator.isChecknames(), true);
    }
 
    @Test(expected = NotValidXMLException.class)
    public void testNotValidXMLException() throws NotValidXMLException {
        throw validator.new NotValidXMLException("", false);
    }
 
    @Test(expected = FileNotFoundException.class)
    public void testFileNotFoundException() throws FileNotFoundException, XMLStreamException, NotValidXMLException {
        validator.isValid(path + "bild.xml");
        
    }
    
 
 
    @Test(expected = XMLStreamException.class)
    public void testXMLStreamException() throws FileNotFoundException, XMLStreamException, NotValidXMLException {
        validator.isValid(path + "xmlStreamEx.xml");
    }
 
    @Test
    public void testIsValidFileValidWithAllChek()
            throws FileNotFoundException, XMLStreamException, NotValidXMLException {
        validator.setCheckdefault(true);
        validator.setCheckdepends(true);
        validator.setChecknames(true);
        validator.isValid(path + "build.xml");
    }
 
    @Test(expected = NotValidXMLException.class)
    public void testCheckdefaultNotValid() throws FileNotFoundException, XMLStreamException, NotValidXMLException {
        validator.setCheckdefault(true);
        validator.isValid(path + "notval.xml");
    }
 
    @Test(expected = NotValidXMLException.class)
    public void testCheckdependsNotValid() throws FileNotFoundException, XMLStreamException, NotValidXMLException {
        validator.setCheckdepends(true);
        validator.isValid(path + "notval.xml");
    }
 
    @Test(expected = NotValidXMLException.class)
    public void testChecknamesNotValid() throws FileNotFoundException, XMLStreamException, NotValidXMLException {
        validator.setChecknames(true);
        validator.isValid(path + "notval.xml");
    }
}

package validator;
 
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import java.io.FileNotFoundException;
import javax.xml.namespace.QName;
import javax.xml.stream.*;
import javax.xml.stream.events.*;
 
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;
 
import validator.Validator.NotValidXMLException;
 
public class Validator extends Task {
    private final List<Buildfile> buildfiles = new ArrayList<Buildfile>();
 
    private boolean checkdepends;
    private boolean checkdefault;
    private boolean checknames;
 
    public boolean isCheckdepends() {
        return checkdepends;
    }
 
    public void setCheckdepends(boolean checkdepends) {
        this.checkdepends = checkdepends;
    }
 
    public boolean isCheckdefault() {
        return checkdefault;
    }
 
    public void setCheckdefault(boolean checkdefault) {
        this.checkdefault = checkdefault;
    }
 
    public boolean isChecknames() {
        return checknames;
    }
 
    public void setChecknames(boolean checknames) {
        this.checknames = checknames;
    }
 
    public void execute() throws BuildException {
        String filePath = buildfile.getLocation();
    System.out.println("filepath = " + filePath);
            try {
                boolean validFile = isValid(filePath);
            } catch (FileNotFoundException | XMLStreamException | NotValidXMLException e) {
                
                e.printStackTrace();
            }
        
    } 
 
    boolean isValid(String filePath) throws FileNotFoundException, XMLStreamException, NotValidXMLException {
        boolean isValid = true;
        try {
            XMLInputFactory factory = XMLInputFactory.newInstance();
            XMLEventReader eventReader = factory.createXMLEventReader(new FileReader(filePath));
            while (eventReader.hasNext()) {
                XMLEvent event = eventReader.nextEvent();
                String mainPoint = null;
                if (event.isStartElement()) {
                    StartElement startElement = event.asStartElement();
                    String qName = startElement.getName().getLocalPart();
                    if (qName.equalsIgnoreCase("project") && (checkdefault == true)) {
                        isValid = true;
                        Attribute defaultAttr = startElement.getAttributeByName(new QName("default"));
                        if (defaultAttr == null) {
                            isValid = false;
                            throw new NotValidXMLException("checkdefaults - project contains default attribute: "
                                    + Boolean.toString(isValid).toUpperCase(), isValid);
                        }
                        mainPoint = defaultAttr.getValue();
                        System.out.println("checkdefaults - project contains default attribute: "
                                + Boolean.toString(isValid).toUpperCase());
                    }
                    if (startElement.getName().getLocalPart().equals("target") && (checkdepends == true)) {
                        isValid = true;
                        Attribute nameTarget = startElement.getAttributeByName(new QName("name"));
                        if (("main".equals(nameTarget.getValue()))
                                && (startElement.getAttributeByName(new QName("depends")) == null)) {
                            isValid = false;
                            throw new NotValidXMLException("checkdepends - <target name='" + nameTarget.getValue()
                                    + "'> with depends are used instead of 'main' point: "
                                    + Boolean.toString(isValid).toUpperCase(), isValid);
                        }
                        System.out.println("checkdepends - <target name='" + nameTarget.getValue()
                                + "'> with depends are used instead of 'main' point: "
                                + Boolean.toString(isValid).toUpperCase());
                    }
                    if (!startElement.getName().getLocalPart().equals("include") && (checknames == true)) {
                        isValid = true;
                        Attribute nameAttr = startElement.getAttributeByName(new QName("name"));
                        if (nameAttr != null) {
                            String name = nameAttr.getValue();
                            isValid = isValid & name.matches("([a-z]|[A-Z]|-|_)*");
                            System.out.println("checknames - name: '" + name + "' contains only letters with '-': "
                                    + Boolean.toString(isValid).toUpperCase());
                            if (isValid == false) {
                                throw new NotValidXMLException(
                                        "checknames - name: '" + name + "' contains only letters with '-': "
                                                + Boolean.toString(isValid).toUpperCase(),
                                        isValid);
                            }
                        }
                    }
                }
            }
        } catch (FileNotFoundException | XMLStreamException e) {
            throw e;
            
            /*e.printStackTrace();
            System.out.println();
         
            return isValid = false;*/
        }
        return isValid;
    }
 
    public class Buildfile {
 
        private String location;
 
        public void setLocation(String location) {
            this.location = location;
            System.out.println("setLocation = " + location);
        }
 
        public String getLocation() {
            System.out.println("getLocation = " + location);
            return location;
        }
    }
 
    Buildfile buildfile = createBuildfile();
 
    public Buildfile createBuildfile() {
        buildfile = new Buildfile();
        return buildfile;
    }
 
    public class NotValidXMLException extends Exception {
        private static final long serialVersionUID = 1L;
 
        private boolean valid;
 
        public NotValidXMLException(String messege, boolean val) {
            super(messege);
            valid = val;
        }
    }
}