import com.galenframework.specs.Spec; //导入依赖的package包/类
public void validate(Spec spec, RelativeElement relativeElement) {
    try {
        PageValidationWrapper pageValidation = getPageValidation(spec, relativeElement);
        ValidationResult result = pageValidation.check(ObjectName, spec);
        if (result.getError() != null) {
            onError(spec, result);
        } else {
            onSuccess(spec, result);

        }
    } catch (Exception ex) {
        Logger.getLogger(General.class
                .getName()).log(Level.SEVERE, null, ex);
        onError(ex);
    }
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
private List<ValidationResult> checkObject(String objectName, List<Spec> specs) {
    List<ValidationResult> validationResults = new LinkedList<>();

    for (Spec spec : specs) {
        tellBeforeSpec(pageValidation, objectName, spec);

        ValidationResult result = pageValidation.check(objectName, spec);
        if (result.getError()!= null) {
            validationResults.add(result);
            tellOnSpecError(pageValidation, objectName, spec, result);
        }
        else {
            tellOnSpecSuccess(pageValidation, objectName, spec, result);
        }
    }

    return validationResults;
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public Spec process(StringCharReader reader, String contextPath) {

    String objectName = reader.readWord();
    if (objectName.isEmpty()) {
        throw new SyntaxException("Missing object name");
    }

    Range range;
    if (reader.hasMore()) {
        range = Expectations.range().read(reader);
    }
    else {
        range = Range.greaterThanOrEquals(new RangeValue(0));
    }


    return createSpec(objectName, range);
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public Spec process(StringCharReader reader, String contextPath) {
    boolean partly = false;

    int initialCursorPosition = reader.currentCursorPosition();

    if (reader.readWord().equals("partly")) {
        partly = true;
    } else {
        reader.moveCursorTo(initialCursorPosition);
    }

    List<String> objectNames = Expectations.readAllWords(reader.takeTheRest());

    if (objectNames.size() == 0) {
        throw new SyntaxException(MISSING_OBJECT_NAME);
    }

    return new SpecContains(objectNames, partly);
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public Spec process(StringCharReader reader, String contextPath) {
    SpecCount.FetchType fetchType = SpecCount.FetchType.parse(word().read(reader));

    String pattern = null;
    if (reader.firstNonWhiteSpaceSymbol() == '\"') {
        pattern = doubleQuotedText().read(reader);
    } else {
        pattern = word().read(reader);
    }

    if (pattern == null || pattern.isEmpty()) {
        throw new SyntaxException("Pattern should not be empty");
    }

    expectNextWord("is", reader);

    ExpectRange rangeExpectation = new ExpectRange();
    rangeExpectation.setNoEndingWord();
    Range range = rangeExpectation.read(reader);

    return new SpecCount(fetchType, pattern, range);
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public Spec process(StringCharReader reader, String contextPath) {
    SpecComponent spec = new SpecComponent();

    int initialPosition = reader.currentCursorPosition();
    if (reader.readWord().equals("frame")) {
        spec.setFrame(true);
    } else {
        reader.moveCursorTo(initialPosition);
    }

    String filePath = reader.readSafeUntilSymbol(',').trim();

    List<Pair<String, String>> unprocessedArguments = Expectations.commaSeparatedRepeatedKeyValues().read(reader);
    spec.setArguments(processArguments(unprocessedArguments));

    if (contextPath != null && !contextPath.equals(".")) {
        filePath = contextPath + File.separator + filePath;
    }

    spec.setSpecPath(filePath);
    return spec;
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public Spec process(StringCharReader reader, String contextPath) {

    String cssPropertyName = reader.readWord();
    String validationTypeString = reader.readWord();
    if (cssPropertyName.isEmpty()) {
        throw new SyntaxException("Missing css property name");
    }
    if (validationTypeString.isEmpty()) {
        throw new SyntaxException("Missing validation type (is, contains, starts, ends, matches)");
    }

    SpecText.Type validationType = SpecText.Type.fromString(validationTypeString);

    String expectedText = Expectations.doubleQuotedText().read(reader);


    if (reader.hasMoreNormalSymbols()) {
        throw new SyntaxException("Too many arguments for spec: " + reader.getTheRest().trim());
    }

    return new SpecCss(cssPropertyName, validationType, expectedText);
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public void onBeforeSpec(PageValidation pageValidation, String objectName, Spec originalSpec) {
    LayoutSpec spec = new LayoutSpec();
    spec.setPlace(originalSpec.getPlace());
    spec.setName(originalSpec.getOriginalText());

    if (originalSpec.getAlias() != null) {
        LayoutSpecGroup group = new LayoutSpecGroup();
        group.setName(originalSpec.getAlias());
        group.addSpec(spec);
        currentReport().getCurrentObject().addSpecGroup(group);
    } else {
        currentReport().getCurrentSpecCollector().add(spec);
    }

    currentReport().setCurrentSpec(spec);
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public void onSpecError(PageValidation pageValidation, String objectName, Spec originalSpec, ValidationResult result) {
    LayoutSpec spec = currentReport().getCurrentSpec();
    addResultToSpec(spec, result);

    if (originalSpec.isOnlyWarn()) {
        spec.setStatus(TestReportNode.Status.WARN);
    }

    try {
        if (result.getError().getImageComparison() != null) {
            spec.setImageComparison(convertImageComparison(objectName, result.getError().getImageComparison()));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Test
public void shouldCheckLayout_inJsTests_andPassCustomJsVariables() throws Exception {
    String testUrl = getClass().getResource("/suites/custom-js-variables-for-checklayout/simple.test.js").getFile();
    GalenMain galen = new GalenMain();
    final List<String> errorMessages = new LinkedList<>();

    CompleteListener listener = new DummyCompleteListener() {
        @Override
        public void onSpecError(PageValidation pageValidation, String objectName, Spec spec, ValidationResult result) {
            errorMessages.addAll(result.getError().getMessages());
        }
    };
    galen.setListener(listener);
    galen.execute("test", testUrl);

    assertThat(errorMessages, hasItems("\"caption\" text is \"Hi my name is John\" but should be \"Hi my name is Jack\""));
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public ValidationResult check(String objectName, Spec spec) {
    ((PageSpecWrapper) this.getPageSpec()).setObjectMap(elementMap);
    SpecValidation<?> specValidation = ValidationFactoryWrapper.getValidation(spec, this);

    ValidationResult result = check(specValidation, objectName, spec);

    if (spec.isOnlyWarn()) {
        result.getError().setOnlyWarn(true);
    }
    return result;
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
public static SpecValidation<? extends Spec> getValidation(Spec spec, PageValidation pageValidation) {
    try {
        return ValidationFactory.getValidation(spec, pageValidation);
    } catch (Exception ex) {
        if (spec.getClass().equals(SpecUrl.class)) {
            return new SpecValidationUrl();
        } else if (spec.getClass().equals(SpecTitle.class)) {
            return new SpecValidationTitle();
        } else if (spec.getClass().equals(SpecAttribute.class)) {
            return new SpecValidationAttribute();
        }
        throw ex;
    }
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
private Spec processAlignment(String objectName, String value, String type) {
    StringCharReader reader = new StringCharReader(value);
    String[] words = ExpectWord.readAllWords(reader);
    Alignment alignment = Alignment.ALL;
    int errorRate = 0;
    if (words.length == 1) {
        errorRate = Parser.parseInt(words[0]);
        if (errorRate == 0) {
            alignment = Alignment.parse(words[0]);
        }
    } else if (words.length == 2) {
        alignment = Alignment.parse(words[0]);
        errorRate = Parser.parseInt(words[1]);
    }

    switch (type) {
        case "horizontally":
            if (alignment.isOneOf(CENTERED, TOP, BOTTOM, ALL)) {
                return new SpecHorizontally(alignment, objectName).withErrorRate(errorRate);
            } else {
                throw new SyntaxException("Horizontal alignment doesn't allow this side: " + alignment.toString());
            }
        case "vertically":
            if (alignment.isOneOf(CENTERED, LEFT, RIGHT, ALL)) {
                return new SpecVertically(alignment, objectName).withErrorRate(errorRate);
            } else {
                throw new SyntaxException("Verticall alignment doesn't allow this side: " + alignment.toString());
            }
        default:
            throw new SyntaxException("Unknown alignment: " + type);
    }
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
public void onError(Spec spec, ValidationResult result) {
    if (result.getError().getImageComparison() != null) {
        onResult(result, Status.FAIL, saveImageComparison(result.getError().getImageComparison()));
    } else {
        onResult(result, Status.FAIL);
    }
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
public PageValidationWrapper getPageValidation(Spec spec, RelativeElement relativeElement) {
    Map<String, WebElement> elementMap = getRelativeElement(relativeElement);
    if (Element != null) {
        elementMap.put(ObjectName, Element);
    }
    if (spec instanceof SpecImage) {
        Optional.ofNullable(((SpecImage) spec).getIgnoredObjectExpressions())
                .ifPresent((ioe) -> ioe.stream().flatMap((expr) -> Stream.of(expr.split(",")))
                .forEach((String object) -> {
                    elementMap.put(object, AObject.findElement(object, Reference));
                }));
    }
    return new PageValidationWrapper(new PageWrapper(Driver, elementMap), elementMap);
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
protected Map<String, List<String>> formatErrorForWiki(Spec spec, ValidationError error) {
    String key = error.isOnlyWarn() ? "warning" : "error";
    key += " on: " + spec.toText();
    Map<String, List<String>> messageMap = new LinkedHashMap<>();
    List<String> messages = error.getMessages();
    messageMap.put(key, new ArrayList<>(messages));
    return messageMap;
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public void onBeforeSpec(PageValidation pageValidation, String objectName, Spec spec) {
    for (ValidationListener listener: listeners) {
        try {
            listener.onBeforeSpec(pageValidation, objectName, spec);
        }
        catch (Exception ex) {
            LOG.error("Unknown error during finishing test", ex);
        }
    }
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public void onSpecError(PageValidation pageValidation, String objectName, Spec spec, ValidationResult result) {
    for (ValidationListener listener: listeners) {
        try {
            listener.onSpecError(pageValidation, objectName, spec, result);
        }
        catch (Exception ex) {
            LOG.error("Unknown error during finishing test", ex);
        }
    }
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
@Override
public void onSpecSuccess(PageValidation pageValidation, String objectName, Spec spec, ValidationResult result) {
    for (ValidationListener listener: listeners) {
        try {
            listener.onSpecSuccess(pageValidation, objectName, spec, result);
        }
        catch (Exception ex) {
            LOG.error("Unknown error during finishing test", ex);
        }
    }
}
 

import com.galenframework.specs.Spec; //导入依赖的package包/类
public ValidationResult asValidationResult(Spec spec) {
    ValidationResult validationResult = new ValidationResult(
            spec,
            this.getValidationObjects(),
            new ValidationError(this.getErrorMessages(), this.getImageComparison()));

    validationResult.setChildValidationResults(childValidationResults);
    return validationResult;
}