public Collection<ValidationResult> getErrors() { Collection<ValidationResult> result = new ArrayList<>(); for (Validator validator : validators) { result.addAll(validator.getErrors()); } return result; }
private ServerContext createServerContext( String gitRemoteUrl, AuthenticationInfo authenticationInfo) { ServerContext.Type type = UrlHelper.isVSO(UrlHelper.getBaseUri(gitRemoteUrl)) ? ServerContext.Type.VSO_DEPLOYMENT : ServerContext.Type.TFS; final Client client = ServerContext.getClient(type, authenticationInfo); final Validator validator = new Validator(client); final UrlHelper.ParseResult uriParseResult = UrlHelper.tryParse(gitRemoteUrl, validator); if (uriParseResult.isSuccess()) { final ServerContextBuilder builder = new ServerContextBuilder() .type(type) .uri(gitRemoteUrl) .authentication(authenticationInfo) .teamProject(validator.getRepository().getProjectReference()) .repository(validator.getRepository()) .collection(validator.getCollection()); // Set the uri of the context to the server uri (TODO change context so that it can be any URI // in the hierarchy) final URI serverUri = URI.create(uriParseResult.getServerUrl()); builder.uri(serverUri); return builder.buildWithClient(client); } return null; }
// escidoc:2110495 released item (1 locator escidoc:2110494) // has reference @Test public void testReleasedItem_2110495() throws Exception { indexer.indexItemsStart(new File(TEST_RESOURCES_OBJECTS + "escidoc_2110495")); indexer.finalizeIndex(); assertTrue( "Expected 1 found " + indexer.getIndexingReport().getFilesIndexingDone(), indexer.getIndexingReport().getFilesIndexingDone() == 1); assertTrue(indexer.getIndexingReport().getFilesErrorOccured() == 0); assertTrue(indexer.getIndexingReport().getFilesSkippedBecauseOfTime() == 0); validator = new Validator(indexer); Map<String, Set<Fieldable>> fieldMap = validator.getFieldsOfDocument(); assertTrue(fieldMap != null); Set<Fieldable> fields = fieldMap.get(getFieldNameFor("stored_filename1")); assertTrue(fields == null); assertTrue(fieldMap.get(getFieldNameFor("stored_filename1")) == null); assertTrue(fieldMap.get(getFieldNameFor("stored_fulltext1")) == null); assertTrue(fieldMap.get(getFieldNameFor("stored_filename")) == null); assertTrue(fieldMap.get(getFieldNameFor("stored_fulltext")) == null); // assertTrue(fieldMap.get("escidoc.property.created-by.name").equals("Nadine Schröder")); validator.compareToReferenceIndex(); assertTrue( Arrays.toString(indexer.getIndexingReport().getErrorList().toArray()), indexer.getIndexingReport().getErrorList().size() == 0); }
/** @param args */ public static void main(String[] args) { CourseEnrollment myCourse; Transcript myTranscript = new Transcript(); // temp variables String code, grade; int credits; System.out.println("Welcome to the transcript application.\n"); while (myTranscript.getUserChoice().equalsIgnoreCase("y")) { Scanner sc = new Scanner(System.in); myCourse = new CourseEnrollment(); code = Validator.validateCourseCode(sc, "Enter course:\t"); myCourse.setCourseCode(code); credits = Validator.validateCredits(sc, "Enter credits:\t", 0, 4); myCourse.setCredits(credits); grade = Validator.validateGrade(sc, "Enter grade:\t"); myCourse.setGrade(grade); myTranscript.addCourse(myCourse); myTranscript.getOverallGPA(); System.out.print("\nAnother line item? (y/n): "); myTranscript.setUserChoice(sc.next()); } System.out.println("\nCourse\t Credits\t Grade\t Quality Points"); System.out.println("\n------------------------------------------------------"); System.out.println(myTranscript); }
/** * Valida un objeto a partir de un validador concreto. <br> * El validador debe extender la clase Validator y soportar (verificado mediante el método * supports) el objeto a validar. Si no, lanza una IllegalArgumentException. <br> * El validador puede tener anotaciones de dependencias de Spring. * * @see com.lynxspa.sdm.web.services.validation.Validator * @see BindingResult#hasFieldErrors() * @param object El objeto a validar * @param validator El validador a utilizar. * @param BindingResult El resultado de la validación, es un objeto BindingResult de Spring. Para * verificar que no hay errores de validación hay que llamar al método hasFieldErrors. * @param result */ public void validate(Object object, Validator v, BindingResult result) { if (!v.supports(object.getClass())) { throw new IllegalArgumentException( "Validator " + v.getClass().toString() + " does not support " + object.getClass()); } v.validate(object, result); }
Validation validate() { Validation validation = new Validation(); for (Validator validator : validators()) { validator.validate(validation); } return validation; }
public void processValidationResults(Validator validator) { List<Reason> reasons = validator.getReasons(); if (isIgnorValidator(validator)) { return; } if (!validator.hasReasons(null)) { if (myProblems.containsKey(validator)) { myProblems.remove(validator); fireStateChanged(); } } else { boolean needUpdateReasons = false; // if (myProblems.containsKey(validator)) { List<Reason> currReasons = myProblems.get(validator); if (!equals(currReasons, reasons)) { needUpdateReasons = true; } } else { needUpdateReasons = true; } // if (needUpdateReasons) { // It's necessary to copy reasons' list here!!! myProblems.put(validator, new ArrayList<Reason>(reasons)); fireStateChanged(); } } }
public void testLegacyValidate() throws Exception { System.out.println("validate - Legacy"); File licenseFile = new File("testing", "LegacyTest.lic"); License license = LicenseIO.importLicense(licenseFile); Validator validator = new Validator(license, pubKey); validator.validate(); }
public boolean validateTmDiff(Validator forward, Validator reverse, ValidationConfig c) { this.tmDiff = (double) (forward.getTm() - reverse.getTm()); if (this.tmDiff > config.tmDifference || this.tmDiff < -(config.tmDifference)) { this.tmFlag = true; return false; } return true; }
private void logValidatorNames() { StringBuilder validatorNamesBuilder = new StringBuilder(); for (Validator validator : validators) { validatorNamesBuilder.append("\t"); validatorNamesBuilder.append(validator.getClass().getCanonicalName()); validatorNamesBuilder.append("\n"); } logger.debug("following validators will be executed:\n" + validatorNamesBuilder); }
/** * Invoke the specified Validators, if any, with the given validation hints. * * <p>Note: Validation hints may get ignored by the actual target Validator. * * @param validationHints one or more hint objects to be passed to a {@link SmartValidator} * @see #setValidator(Validator) * @see SmartValidator#validate(Object, Errors, Object...) */ public void validate(Object... validationHints) { for (Validator validator : getValidators()) { if (!ObjectUtils.isEmpty(validationHints) && validator instanceof SmartValidator) { ((SmartValidator) validator).validate(getTarget(), getBindingResult(), validationHints); } else if (validator != null) { validator.validate(getTarget(), getBindingResult()); } } }
public boolean validate() { long notErrors = 0; for (Validator validator : validators) { if (validator.validate()) { notErrors++; } } return notErrors == validators.size(); }
public static void main(String[] args) { // TODO Auto-generated method stub Scanner sc = new Scanner(System.in); String choice = "y"; while (choice.equalsIgnoreCase("y")) { System.out.println("Enter Name:"); String Name = sc.nextLine(); while (!(Validator.ValidateName(Name))) { System.out.println("Invalid Entry.Enter a Name"); Name = sc.nextLine(); } System.out.println("Enter Age:"); String input = sc.nextLine(); while (!(Validator.ValidateAge(input))) { System.out.println("Invalid Entry.Enter Age:"); input = sc.nextLine(); } int age = Integer.parseInt(input); System.out.println("Enter Height in inches:"); input = sc.nextLine(); while (!(Validator.ValidateHeight(input))) { System.out.println("Invalid Entry.Enter Height:"); input = sc.nextLine(); } int height = Integer.parseInt(input); System.out.println("Enter Weight in lbs:"); input = sc.nextLine(); while (!(Validator.ValidateWeight(input))) { System.out.println("Invalid Entry.Enter Weight:"); input = sc.nextLine(); } int weight = Integer.parseInt(input); System.out.println("Enter your favourite decimal number between 0 and 1:"); input = sc.nextLine(); while (!(Validator.ValidateNumber(input))) { System.out.println("Invalid Entry.Enter a new Number:"); input = sc.nextLine(); } double num = Double.parseDouble(input); System.out.println( "Name: " + Name + "\nAge: " + age + "\nHeight: " + height + " inches\nWeight: " + weight + " lbs" + "\nFavorite Number: " + num); System.out.println("Do you wish to continue:(y/n)?"); choice = sc.nextLine(); } sc.close(); }
public ValidationResult getFirstError() { for (Validator validator : validators) { List<ValidationResult> errors = validator.getErrors(); if (errors != null && !errors.isEmpty()) { return errors.get(0); } } return null; }
public static Validator getValidator(HtmlVersion version) { Collection<? extends Validator> validators = Lookup.getDefault().lookupAll(Validator.class); for (Validator v : validators) { if (v.canValidate(version)) { return v; } } return null; }
private void assertValidators(Validator... validators) { Assert.notNull(validators, "Validators required"); for (Validator validator : validators) { if (validator != null && (getTarget() != null && !validator.supports(getTarget().getClass()))) { throw new IllegalStateException( "Invalid target for Validator [" + validator + "]: " + getTarget()); } } }
public static Long getId(final Object model, boolean checkValidity) { Long id = null; if (model != null) { if (checkValidity) { Validator.checkValidModel(model); } id = Validator.checkValidId(model); } return id; }
@SuppressWarnings("unchecked") static void initCollections(final Object model, final Nest<?> nest) { if (model == null || nest == null) { return; } for (Field field : model.getClass().getDeclaredFields()) { field.setAccessible(true); try { if (field.isAnnotationPresent(CollectionList.class)) { Validator.checkValidCollection(field); List<Object> list = (List<Object>) field.get(model); if (list == null) { CollectionList annotation = field.getAnnotation(CollectionList.class); RedisList<Object> redisList = new RedisList<Object>(annotation.of(), nest, field, model); field.set(model, redisList); } } if (field.isAnnotationPresent(CollectionSet.class)) { Validator.checkValidCollection(field); Set<Object> set = (Set<Object>) field.get(model); if (set == null) { CollectionSet annotation = field.getAnnotation(CollectionSet.class); RedisSet<Object> redisSet = new RedisSet<Object>(annotation.of(), nest, field, model); field.set(model, redisSet); } } if (field.isAnnotationPresent(CollectionSortedSet.class)) { Validator.checkValidCollection(field); Set<Object> sortedSet = (Set<Object>) field.get(model); if (sortedSet == null) { CollectionSortedSet annotation = field.getAnnotation(CollectionSortedSet.class); RedisSortedSet<Object> redisSortedSet = new RedisSortedSet<Object>(annotation.of(), annotation.by(), nest, field, model); field.set(model, redisSortedSet); } } if (field.isAnnotationPresent(CollectionMap.class)) { Validator.checkValidCollection(field); Map<Object, Object> map = (Map<Object, Object>) field.get(model); if (map == null) { CollectionMap annotation = field.getAnnotation(CollectionMap.class); RedisMap<Object, Object> redisMap = new RedisMap<Object, Object>( annotation.key(), annotation.value(), nest, field, model); field.set(model, redisMap); } } } catch (IllegalArgumentException e) { throw new InvalidFieldException(); } catch (IllegalAccessException e) { throw new InvalidFieldException(); } } }
@Override public List<ValidationFailure> validate() { final List<ValidationFailure> result = Lists.newArrayList(); for (Validator validator : validators) { final List<ValidationFailure> failures = validator.validate(); if (failures != null && !failures.isEmpty()) { result.addAll(failures); } } return result; }
/** * Called to validate the form. If an error is found, it will be displayed in the corresponding * field. * * @return boolean true if the form is not valid, otherwise false */ public boolean validate() { boolean formValid = true; boolean asError; for (Validator v : mValidates) { asError = v.validate(); if (asError && formValid) { formValid = false; } } return formValid; }
public static void main(String[] args) { Transcript transcript = new Transcript(); ArrayList<CourseEnrollment> alist = new ArrayList<CourseEnrollment>(); Scanner scan = new Scanner(System.in); String course = ""; int credits = 0; String grade = ""; System.out.println("Welome to the Transcript Application"); System.out.println(); System.out.println("Do you want to enter an item?(y/n) "); String choice = scan.next(); scan.nextLine(); while (choice.equalsIgnoreCase("y")) { course = Validator.getString(scan, "Enter course: "); credits = Validator.getInt(scan, "Enter credits: ", 1, 4); grade = Validator.getString(scan, "Enter grade: "); CourseEnrollment courseenrollment = new CourseEnrollment(); courseenrollment.setCode(course); courseenrollment.setCredits(credits); courseenrollment.setGrade(grade); transcript.addCourse(courseenrollment); alist = transcript.getCourses(); System.out.print("Continue? (y/n): "); choice = scan.nextLine(); System.out.println(); } alist = transcript.getCourses(); System.out.println("Course\t\tCredits\t\tGrade\t\tQuality Point"); System.out.println("------\t\t-------\t\t-----\t\t-------------"); for (CourseEnrollment print : alist) { System.out.println( print.getCode() + "\t" + print.getCredits() + "\t\t" + print.getGrade() + "\t\t" + print.getGPAgrade()); System.out.println(); } System.out.println("\t\t\t\t\tGPA\t" + transcript.getOverallGPA()); }
/** Handle being deleted by cleaning up validators and so forth. */ public void handleDelete() { for (Property prop : properties.values()) { if (prop.getValidators() != null) { for (String validatorName : prop.getValidators()) { Validator validator = getRobotTree().getValidator(validatorName); if (validator != null) { validator.delete(this, prop.getName()); } } } } }
/** {@inheritDoc} */ @Override public void validate(Object node, JsonPointer at, ErrorHandler handler) throws SchemaException { for (Validator v : validators) { try { v.validate(node, at, new FailFastErrorHandler()); return; } catch (ValidationException e) { // Only one helpers should success to be overall success. } } handler.error(new ValidationException("Invalid union validators.", getPath(at, null))); }
@Test public void validateWorksIfUpdateDerivedValuesWasCalled() { Validator v = new Validator(); v.enqueue( new DummyDomainObject() { @Override public void updateDerivedValues() { super.updateDerivedValues(); } }); // no exception means it passed v.validate(); }
public boolean isValid(String value) { errors = new ArrayList<>(); boolean success = true; for (Validator validator : validators) { if (!validator.isValid(value)) { errors.add(validator.getErrorMessage()); success = false; } } return success; }
/** * Validates object against a JSON schema. * * @param o object to validate. * @param schemaResource schema used for validation. * @return {@link Validator} */ public static Validator validateJson(Object o, String schemaResource) { JsonNode json = objectToJson(o); JsonNode schema; try { schema = JsonLoader.fromResource(schemaResource); return validateJson(json, schema); } catch (IOException e) { log.info(String.format("JsonUtils.validateJson(): Unable to load schema json")); Validator res = new Validator(); res.addError("jsonerror", "Unable to load schema"); return res; } }
@Test public void testIsValidUrl_Second_Solution() throws Exception { PowerMockito.mockStatic(Validator.class); String url = "This is not an url"; PowerMockito.doReturn(true).when(Validator.class, "isValidUrlStatic", url); boolean result = Validator.isValidUrlStatic(url); Assert.assertTrue("Should be true", result); // PowerMockito.verifyStatic(Mockito.times(1)); PowerMockito.verifyStatic(); // Same as above Validator.isValidUrlStatic(url); }
@Test public void testIsValidUrl_First_Solution() { PowerMockito.mockStatic(Validator.class); String url = "This is not an url"; PowerMockito.when(Validator.isValidUrlStatic(url)).thenReturn(true); boolean result = Validator.isValidUrlStatic(url); result = Validator.isValidUrlStatic(url); Assert.assertTrue("Should be true", result); PowerMockito.verifyStatic(Mockito.times(2)); Validator.isValidUrlStatic(url); }
/** @param args */ public static void main(String[] args) { Validator errorHander; try { // File docFile = new File("src/com/amitk/xml/xsd/hello/PurchaseOrder.xml"); String schemaFileName = // "PurchaseOrderSchema.xsd"; "Order.xsd"; String xmlFileName = // "PurchaseOrder.xml"; "OrderCreate.xml"; String nameSpace = "http://www.matson.com/milportal/schema"; DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setValidating(true); dbf.setNamespaceAware(true); dbf.setAttribute( "http://java.sun.com/xml/jaxp/properties/schemaLanguage", "http://www.w3.org/2001/XMLSchema"); dbf.setAttribute( "http://java.sun.com/xml/jaxp/properties/schemaSource", // nameSpace + " " + "http://10.8.4.118:9050/MILOrderTrackEEM/static/Order.xsd"); /* parser.setProperty("http://apache.org/xml/properties/schema/external-schemaLocation", nameSpace + " " + //"C:\\AmitK\\work\\project\\Learning\\EclipseWorkSpace\\XML\\src\\com\\amitk\\xml\\xsd\\hello\\" + schemaFileName); "http://10.8.4.118:9050/MILOrderTrackEEM/static/Order.xsd"); */ DocumentBuilder builder = dbf.newDocumentBuilder(); System.out.println( "Document builder impl:" + builder.getDOMImplementation().getClass().getName()); errorHander = new Validator(); builder.setErrorHandler(errorHander); // parser.setProperty(name, value)ErrorHandler(errorHander); // parser.parse("src/com/amitk/xml/xsd/hello/" + xmlFileName, errorHander); builder.parse("src/com/amitk/xml/xsd/hello/" + xmlFileName); if (errorHander.hasErrors()) { // errorHander.saxParseException.printStackTrace(); System.out.println(errorHander.getErrors()); } else { System.out.println("xml file parsed successfully"); } } catch (Exception e) { e.printStackTrace(); } }
/** * Checks whether longitude and latitude is within bounds. * * @param latitude * @param longitude * @return true if both are within bounds. */ public boolean isLegal(double latitude, double longitude) { if (Validator.validCoords(latitude, longitude)) { return true; } log.debug("out of bounds"); return false; }