How to use FileName method of validation Package

...57}58func (s StepValidationError) Step() *gauge.Step {59	return s.step60}61func (s StepValidationError) FileName() string {62	return s.fileName63}64func (s StepValidationError) ErrorType() gm.StepValidateResponse_ErrorType {65	return *s.errorType66}67// Error prints a step validation error with filename, line number, error message, step text and suggestion in case of step implementation not found.68func (s StepValidationError) Error() string {69	return fmt.Sprintf("%s:%d %s => '%s'", s.fileName, s.step.LineNo, s.message, s.step.GetLineText())70}71func (s StepValidationError) Suggestion() string {72	return s.suggestion73}74// Error prints a spec validation error with filename and error message.75func (s SpecValidationError) Error() string {76	return fmt.Sprintf("%s %s", s.fileName, s.message)77}78// NewSpecValidationError generates new spec validation error with error message and filename.79func NewSpecValidationError(m string, f string) SpecValidationError {80	return SpecValidationError{message: m, fileName: f}81}82// NewStepValidationError generates new step validation error with error message, filename and error type.83func NewStepValidationError(s *gauge.Step, m string, f string, e *gm.StepValidateResponse_ErrorType, suggestion string) StepValidationError {84	return StepValidationError{step: s, message: m, fileName: f, errorType: e, suggestion: suggestion}85}86// Validate validates specs and if it has any errors, it exits.87func Validate(args []string) {88	if len(args) == 0 {89		args = append(args, util.GetSpecDirs()...)90	}91	res := ValidateSpecs(args, false)92	if len(res.Errs) > 0 {93		os.Exit(1)94	}95	if res.SpecCollection.Size() < 1 {96		logger.Infof(true, "No specifications found in %s.", strings.Join(args, ", "))97		err := res.Runner.Kill()98		if err != nil {99			logger.Errorf(false, "unable to kill runner: %s", err.Error())100		}101		if res.ParseOk {102			os.Exit(0)103		}104		os.Exit(1)105	}106	err := res.Runner.Kill()107	if err != nil {108		logger.Errorf(false, "unable to kill runner: %s", err.Error())109	}110	if res.ErrMap.HasErrors() {111		os.Exit(1)112	}113	logger.Infof(true, "No errors found.")114}115//TODO : duplicate in execute.go. Need to fix runner init.116func startAPI(debug bool) runner.Runner {117	sc := api.StartAPI(debug)118	select {119	case runner := <-sc.RunnerChan:120		return runner121	case err := <-sc.ErrorChan:122		logger.Fatalf(true, "Failed to start gauge API: %s", err.Error())123	}124	return nil125}126type ValidationResult struct {127	SpecCollection *gauge.SpecCollection128	ErrMap         *gauge.BuildErrors129	Runner         runner.Runner130	Errs           []error131	ParseOk        bool132}133// NewValidationResult creates a new Validation result134func NewValidationResult(s *gauge.SpecCollection, errMap *gauge.BuildErrors, r runner.Runner, parseOk bool, e ...error) *ValidationResult {135	return &ValidationResult{SpecCollection: s, ErrMap: errMap, Runner: r, ParseOk: parseOk, Errs: e}136}137// ValidateSpecs parses the specs, creates a new validator and call the runner to get the validation result.138func ValidateSpecs(specsToValidate []string, debug bool) *ValidationResult {139	logger.Debug(true, "Parsing started.")140	conceptDict, res, err := parser.ParseConcepts()141	if err != nil {142		logger.Fatalf(true, "Unable to parse : %s", err.Error())143	}144	errMap := gauge.NewBuildErrors()145	specs, specsFailed := parser.ParseSpecs(specsToValidate, conceptDict, errMap)146	logger.Debug(true, "Parsing completed.")147	r := startAPI(debug)148	validationErrors := NewValidator(specs, r, conceptDict).Validate()149	errMap = getErrMap(errMap, validationErrors)150	specs = parser.GetSpecsForDataTableRows(specs, errMap)151	printValidationFailures(validationErrors)152	showSuggestion(validationErrors)153	if !res.Ok {154		err := r.Kill()155		if err != nil {156			logger.Errorf(true, "unable to kill runner: %s", err.Error())157		}158		return NewValidationResult(nil, nil, nil, false, errors.New("Parsing failed"))159	}160	if specsFailed {161		return NewValidationResult(gauge.NewSpecCollection(specs, false), errMap, r, false)162	}163	return NewValidationResult(gauge.NewSpecCollection(specs, false), errMap, r, true)164}165func getErrMap(errMap *gauge.BuildErrors, validationErrors validationErrors) *gauge.BuildErrors {166	for spec, valErrors := range validationErrors {167		for _, err := range valErrors {168			switch e := err.(type) {169			case StepValidationError:170				errMap.StepErrs[e.step] = e171			case SpecValidationError:172				errMap.SpecErrs[spec] = append(errMap.SpecErrs[spec], err.(SpecValidationError))173			}174		}175		skippedScnInSpec := 0176		for _, scenario := range spec.Scenarios {177			fillScenarioErrors(scenario, errMap, scenario.Steps)178			if _, ok := errMap.ScenarioErrs[scenario]; ok {179				skippedScnInSpec++180			}181		}182		if len(spec.Scenarios) > 0 && skippedScnInSpec == len(spec.Scenarios) {183			errMap.SpecErrs[spec] = append(errMap.SpecErrs[spec], errMap.ScenarioErrs[spec.Scenarios[0]]...)184		}185		fillSpecErrors(spec, errMap, append(spec.Contexts, spec.TearDownSteps...))186	}187	return errMap188}189func fillScenarioErrors(scenario *gauge.Scenario, errMap *gauge.BuildErrors, steps []*gauge.Step) {190	for _, step := range steps {191		if step.IsConcept {192			fillScenarioErrors(scenario, errMap, step.ConceptSteps)193		}194		if err, ok := errMap.StepErrs[step]; ok { // nolint195			errMap.ScenarioErrs[scenario] = append(errMap.ScenarioErrs[scenario], err)196		}197	}198}199func fillSpecErrors(spec *gauge.Specification, errMap *gauge.BuildErrors, steps []*gauge.Step) {200	for _, context := range steps {201		if context.IsConcept {202			fillSpecErrors(spec, errMap, context.ConceptSteps)203		}204		if err, ok := errMap.StepErrs[context]; ok { // nolint205			errMap.SpecErrs[spec] = append(errMap.SpecErrs[spec], err)206			for _, scenario := range spec.Scenarios {207				if _, ok := errMap.ScenarioErrs[scenario]; !ok {208					errMap.ScenarioErrs[scenario] = append(errMap.ScenarioErrs[scenario], err)209				}210			}211		}212	}213}214func printValidationFailures(validationErrors validationErrors) {215	for _, e := range FilterDuplicates(validationErrors) {216		logger.Errorf(true, "[ValidationError] %s", e.Error())217	}218}219func FilterDuplicates(validationErrors validationErrors) []error {220	filteredErrs := make([]error, 0)221	exists := make(map[string]bool)222	for _, errs := range validationErrors {223		for _, e := range errs {224			var val string225			if vErr, ok := e.(StepValidationError); ok {226				val = vErr.step.Value + vErr.step.FileName + strconv.Itoa(e.(StepValidationError).step.LineNo)227			} else if vErr, ok := e.(SpecValidationError); ok {228				val = vErr.message + vErr.fileName229			} else {230				continue231			}232			if _, ok := exists[val]; !ok {233				exists[val] = true234				filteredErrs = append(filteredErrs, e)235			}236		}237	}238	return filteredErrs239}240type validationErrors map[*gauge.Specification][]error241func NewValidator(s []*gauge.Specification, r runner.Runner, c *gauge.ConceptDictionary) *validator {242	return &validator{specsToExecute: s, runner: r, conceptsDictionary: c}243}244func (v *validator) Validate() validationErrors {245	validationStatus := make(validationErrors)246	logger.Debug(true, "Validation started.")247	specValidator := &SpecValidator{runner: v.runner, conceptsDictionary: v.conceptsDictionary, stepValidationCache: make(map[string]error)}248	for _, spec := range v.specsToExecute {249		specValidator.specification = spec250		validationErrors := specValidator.validate()251		if len(validationErrors) != 0 {252			validationStatus[spec] = validationErrors253		}254	}255	if len(validationStatus) > 0 {256		return validationStatus257	}258	logger.Debug(true, "Validation completed.")259	return nil260}261func (v *SpecValidator) validate() []error {262	queue := &gauge.ItemQueue{Items: v.specification.AllItems()}263	v.specification.Traverse(v, queue)264	return v.validationErrors265}266// Validates a step. If validation result from runner is not valid then it creates a new validation error.267// If the error type is StepValidateResponse_STEP_IMPLEMENTATION_NOT_FOUND then gives suggestion with step implementation stub.268func (v *SpecValidator) Step(s *gauge.Step) {269	if s.IsConcept {270		for _, c := range s.ConceptSteps {271			v.Step(c)272		}273		return274	}275	val, ok := v.stepValidationCache[s.Value]276	if !ok {277		err := v.validateStep(s)278		if err != nil {279			v.validationErrors = append(v.validationErrors, err)280		}281		v.stepValidationCache[s.Value] = err282		return283	}284	if val != nil {285		valErr := val.(StepValidationError)286		if s.Parent == nil {287			v.validationErrors = append(v.validationErrors,288				NewStepValidationError(s, valErr.message, v.specification.FileName, valErr.errorType, valErr.suggestion))289		} else {290			cpt := v.conceptsDictionary.Search(s.Parent.Value)291			v.validationErrors = append(v.validationErrors,292				NewStepValidationError(s, valErr.message, cpt.FileName, valErr.errorType, valErr.suggestion))293		}294	}295}296var invalidResponse gm.StepValidateResponse_ErrorType = -1297func (v *SpecValidator) validateStep(s *gauge.Step) error {298	stepValue, err := parser.ExtractStepValueAndParams(s.LineText, s.HasInlineTable)299	if err != nil {300		return nil301	}302	protoStepValue := gauge.ConvertToProtoStepValue(stepValue)303	m := &gm.Message{MessageType: gm.Message_StepValidateRequest,304		StepValidateRequest: &gm.StepValidateRequest{StepText: s.Value, NumberOfParameters: int32(len(s.Args)), StepValue: protoStepValue}}305	r, err := v.runner.ExecuteMessageWithTimeout(m)306	if err != nil {307		return NewStepValidationError(s, err.Error(), v.specification.FileName, &invalidResponse, "")308	}309	if r.GetMessageType() == gm.Message_StepValidateResponse {310		res := r.GetStepValidateResponse()311		if !res.GetIsValid() {312			msg := getMessage(res.GetErrorType().String())313			suggestion := res.GetSuggestion()314			if s.Parent == nil {315				vErr := NewStepValidationError(s, msg, v.specification.FileName, &res.ErrorType, suggestion)316				return vErr317			}318			cpt := v.conceptsDictionary.Search(s.Parent.Value)319			vErr := NewStepValidationError(s, msg, cpt.FileName, &res.ErrorType, suggestion)320			return vErr321		}322		return nil323	}324	return NewStepValidationError(s, "Invalid response from runner for Validation request", v.specification.FileName, &invalidResponse, "")325}326func getMessage(message string) string {327	lower := strings.ToLower(strings.Replace(message, "_", " ", -1))328	return strings.ToUpper(lower[:1]) + lower[1:]329}330func (v *SpecValidator) TearDown(step *gauge.TearDown) {331}332func (v *SpecValidator) Heading(heading *gauge.Heading) {333}334func (v *SpecValidator) Tags(tags *gauge.Tags) {335}336func (v *SpecValidator) Table(dataTable *gauge.Table) {337}338func (v *SpecValidator) Scenario(scenario *gauge.Scenario) {339}340func (v *SpecValidator) Comment(comment *gauge.Comment) {341}342func (v *SpecValidator) DataTable(dataTable *gauge.DataTable) {343}344// Validates data table for the range, if any error found append to the validation errors345func (v *SpecValidator) Specification(specification *gauge.Specification) {346	v.validationErrors = make([]error, 0)347	err := validateDataTableRange(specification.DataTable.Table.GetRowCount())348	if err != nil {349		v.validationErrors = append(v.validationErrors, NewSpecValidationError(err.Error(), specification.FileName))350	}351}352func validateDataTableRange(rowCount int) error {353	if TableRows == "" {354		return nil355	}356	if strings.Contains(TableRows, "-") {357		indexes := strings.Split(TableRows, "-")358		if len(indexes) > 2 {359			return fmt.Errorf("Table rows range '%s' is invalid => Table rows range should be of format rowNumber-rowNumber", TableRows)360		}361		if err := validateTableRow(indexes[0], rowCount); err != nil {362			return err363		}...

1// This file is part of Arduino Lint.2//3// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)4//5// This software is released under the GNU General Public License, either6// version 3 of the License, or (at your option) any later version.7// This license covers the main part of Arduino Lint.8// The terms of this license can be found at:9// https://www.gnu.org/licenses/gpl-3.0.en.html10//11// You can be released from the requirements of the above licenses by purchasing12// a commercial license. Buying such a license is mandatory if you want to13// modify or otherwise use the software for commercial activities involving the14// Arduino software without disclosing the source code of your own applications.15// To purchase a commercial license, send an email to license@arduino.cc.16// Package schema contains code for working with JSON schema.17package schema18import (19	"bytes"20	"encoding/json"21	"fmt"22	"io"23	"io/ioutil"24	"path"25	"github.com/ory/jsonschema/v3"26	"github.com/sirupsen/logrus"27	"github.com/xeipuuv/gojsonreference"28)29// dataLoaderType is the signature of the function that returns the byte encoded data associated with the given file name.30type dataLoaderType func(filename string) ([]byte, error)31// Schema is the type of the compiled JSON schema object.32type Schema struct {33	Compiled   *jsonschema.Schema34	dataLoader dataLoaderType // Function to load the schema data.35}36// ValidationResult is the type of the result of the validation of the instance document against the JSON schema.37type ValidationResult struct {38	Result     *jsonschema.ValidationError39	dataLoader dataLoaderType // Function used to load the JSON schema data.40}41// Compile compiles the schema files specified by the filename arguments and returns the compiled schema.42func Compile(schemaFilename string, referencedSchemaFilenames []string, dataLoader dataLoaderType) Schema {43	compiler := jsonschema.NewCompiler()44	// Define a custom schema loader for the binary encoded schema.45	compiler.LoadURL = func(schemaFilename string) (io.ReadCloser, error) {46		schemaData, err := dataLoader(schemaFilename)47		if err != nil {48			return nil, err49		}50		return ioutil.NopCloser(bytes.NewReader(schemaData)), nil51	}52	// Load the referenced schemas.53	for _, referencedSchemaFilename := range referencedSchemaFilenames {54		if err := loadReferencedSchema(compiler, referencedSchemaFilename, dataLoader); err != nil {55			panic(err)56		}57	}58	// Compile the schema.59	compiledSchema, err := compiler.Compile(schemaFilename)60	if err != nil {61		panic(err)62	}63	return Schema{64		Compiled:   compiledSchema,65		dataLoader: dataLoader,66	}67}68// Validate validates an instance against a JSON schema and returns nil if it was success, or the69// jsonschema.ValidationError object otherwise.70func Validate(instanceInterface map[string]interface{}, schemaObject Schema) ValidationResult {71	validationError := schemaObject.Compiled.ValidateInterface(instanceInterface)72	validationResult := ValidationResult{73		Result:     nil,74		dataLoader: schemaObject.dataLoader,75	}76	if validationError != nil {77		result, ok := validationError.(*jsonschema.ValidationError)78		if !ok {79			panic(validationError)80		}81		validationResult.Result = result82	}83	if validationResult.Result == nil {84		logrus.Debug("Schema validation of instance document passed")85	} else {86		logrus.Debug("Schema validation of instance document failed:")87		logValidationError(validationResult)88		logrus.Trace("-----------------------------------------------")89	}90	return validationResult91}92// loadReferencedSchema adds a schema that is referenced by the parent schema to the compiler object.93func loadReferencedSchema(compiler *jsonschema.Compiler, schemaFilename string, dataLoader dataLoaderType) error {94	// Get the $id value from the schema to use as the `url` argument for the `compiler.AddResource()` call.95	id, err := schemaID(schemaFilename, dataLoader)96	if err != nil {97		return err98	}99	schemaData, err := dataLoader(schemaFilename)100	if err != nil {101		return err102	}103	return compiler.AddResource(id, bytes.NewReader(schemaData))104}105// schemaID returns the value of the schema's $id key.106func schemaID(schemaFilename string, dataLoader dataLoaderType) (string, error) {107	schemaInterface := unmarshalJSONFile(schemaFilename, dataLoader)108	id, ok := schemaInterface.(map[string]interface{})["$id"].(string)109	if !ok {110		return "", fmt.Errorf("Schema %s is missing an $id keyword", schemaFilename)111	}112	return id, nil113}114// unmarshalJSONFile returns the data from a JSON file.115func unmarshalJSONFile(filename string, dataLoader dataLoaderType) interface{} {116	data, err := dataLoader(filename)117	if err != nil {118		panic(err)119	}120	var dataInterface interface{}121	if err := json.Unmarshal(data, &dataInterface); err != nil {122		panic(err)123	}124	return dataInterface125}126// logValidationError logs the schema validation error data.127func logValidationError(validationError ValidationResult) {128	logrus.Trace("--------Schema validation failure cause--------")129	logrus.Tracef("Error message: %s", validationError.Result.Error())130	logrus.Tracef("Instance pointer: %v", validationError.Result.InstancePtr)131	logrus.Tracef("Schema URL: %s", validationError.Result.SchemaURL)132	logrus.Tracef("Schema pointer: %s", validationError.Result.SchemaPtr)133	logrus.Tracef("Schema pointer value: %v", validationErrorSchemaPointerValue(validationError))134	logrus.Tracef("Failure context: %v", validationError.Result.Context)135	logrus.Tracef("Failure context type: %T", validationError.Result.Context)136	// Recursively log all causes.137	for _, validationErrorCause := range validationError.Result.Causes {138		logValidationError(139			ValidationResult{140				Result:     validationErrorCause,141				dataLoader: validationError.dataLoader,142			},143		)144	}145}146// validationErrorSchemaPointerValue returns the object identified by the validation error's schema JSON pointer.147func validationErrorSchemaPointerValue(validationError ValidationResult) interface{} {148	return schemaPointerValue(validationError.Result.SchemaURL, validationError.Result.SchemaPtr, validationError.dataLoader)149}150// schemaPointerValue returns the object identified by the given JSON pointer from the schema file.151func schemaPointerValue(schemaURL, schemaPointer string, dataLoader dataLoaderType) interface{} {152	return jsonPointerValue(schemaPointer, path.Base(schemaURL), dataLoader)153}154// jsonPointerValue returns the object identified by the given JSON pointer from the JSON file.155func jsonPointerValue(jsonPointer string, fileName string, dataLoader dataLoaderType) interface{} {156	jsonReference, err := gojsonreference.NewJsonReference(jsonPointer)157	if err != nil {158		panic(err)159	}160	jsonInterface := unmarshalJSONFile(fileName, dataLoader)161	jsonPointerValue, _, err := jsonReference.GetPointer().Get(jsonInterface)162	if err != nil {163		panic(err)164	}165	return jsonPointerValue166}...

...12	"video":      "file_type/random.file_format",13}14// GenerateFileURLInput .....15type GenerateFileURLInput struct {16	FileName   string `json:"file_name" query:"file_name"`17	FileFormat string `json:"file_format" query:"file_format"`18	FileType   string `json:"file_type" query:"file_type"`19}20// Validate ......21func (i *GenerateFileURLInput) Validate() error {22	return validation.ValidateStruct(i,23		validation.Field(&i.FileFormat, validation.Required),24		validation.Field(&i.FileType, validation.Required),25	)26}27// AsURI ......28func (i *GenerateFileURLInput) AsURI() string {29	i.preprocessParams()30	randomString := uuid.New().String()31	randomString = strings.Replace(randomString, "-", "", -1)32	uri := filePathPatternMapping[i.FileType]33	uri = strings.Replace(uri, "file_type", i.FileType, -1)34	uri = strings.Replace(uri, "file_name", i.FileName, -1)35	uri = strings.Replace(uri, "random", randomString, -1)36	uri = strings.Replace(uri, "file_format", i.FileFormat, -1)37	return uri38}39func (i *GenerateFileURLInput) preprocessParams() {40	var fileName, fileFormat, fileType string41	fileType = strings.TrimSpace(i.FileType)42	fileType = strings.ToLower(fileType)43	i.FileType = fileType44	pattern := regexp.MustCompile(`/[^a-zA-Z0-9._]+/`)45	fileName = strings.ToLower(i.FileName)46	fileName = strings.TrimLeft(fileName, " ")47	fileName = strings.TrimRight(fileName, " ")48	fileName = strings.Replace(fileName, " ", "_", -1)49	fileName = pattern.ReplaceAllString(fileName, "")50	if fileName != "" {51		fileFormat = filepath.Ext(fileName)52	}53	i.FileName = fileName54	if fileFormat == "" {55		fileFormat = i.FileFormat56	}57	fileFormat = strings.TrimSpace(fileFormat)58	fileFormat = strings.ToLower(fileFormat)59	i.FileFormat = fileFormat60}...

1import (2func main() {3    v := validation.Validation{}4    v.FileName("test.txt")5    fmt.Println(v.HasErrors())6    fmt.Println(v.Errors)7}

1import (2func main() {3	fmt.Println("Enter file name")4	fmt.Scanln(&fileName)5	validate := validation.NewValidation()6	fileName = validate.FileName(fileName)7	fmt.Println(fileName)8}9import (10type Validation struct{}11func NewValidation() *Validation {12	return &Validation{}13}14func (v *Validation) FileName(fileName string) string {15	reg, _ := regexp.Compile("[^a-zA-Z0-9]+")

1import (2func main() {3    fmt.Println(validation.FileName("file.txt"))4    fmt.Println(validation.FileName("file"))5    fmt.Println(validation.FileName("file."))6    fmt.Println(validation.FileName("file."))7    fmt.Println(validation.FileName("file..txt"))8    fmt.Println(validation.FileName("file.txt."))9    fmt.Println(validation.FileName("file.txt.txt"))10    fmt.Println(validation.FileName("file.txt.txt.txt"))11    fmt.Println(validation.FileName("file.txt.txt.txt."))12    fmt.Println(validation.FileName("file.txt.txt.txt.txt"))13    fmt.Println(validation.FileName("file.txt.txt.txt.txt.txt"))14    fmt.Println(validation.FileName("file.txt.txt.txt.txt.txt.txt"))15    fmt.Println(validation.FileName("file.txt.txt.txt.txt.txt.txt.txt"))16    fmt.Println(validation.FileName("file.txt.txt.txt.txt.txt.txt.txt.txt"))17    fmt.Println(validation.FileName("file.txt.txt.txt.txt.txt.txt.txt.txt.txt"))18    fmt.Println(validation.FileName("

1import (2func main() {3    fmt.Println(validation.FileName("test.txt"))4}5import "regexp"6func FileName(name string) bool {7    return regexp.MustCompile(`^[a-z0-9_\-\.]+$`).MatchString(name)8}

1import "fmt"2import "myProject/Validation"3func main() {4    fmt.Println("Enter File Name")5    fmt.Scanf("%s", &file)6    valid := Validation.New()7    valid.FileName(file)8}9import "fmt"10import "regexp"11type Validation struct {12}13func New() *Validation {14    return &Validation{}15}16func (v *Validation) FileName(file string) {17    valid = regexp.MustCompile(`^[a-zA-Z0-9_\-\.]+$`).MatchString(file)18    if valid == true {19        fmt.Println("Valid File Name")20    } else {21        fmt.Println("Invalid File Name")22    }23}

1import (2func main() {3    fmt.Println(validation.FileName("test.txt"))4}5import (6func main() {7    fmt.Println(validation.IsFloat("123.45"))8}9import (10func main() {11    fmt.Println(validation.IsInt("123"))12}13import (14func main() {15    fmt.Println(validation.IsLowerCase("test"))16}17import (18func main() {19    fmt.Println(validation.IsUpperCase("TEST"))20}21import (22func main() {23    fmt.Println(validation.IsString("test"))24}25import (26func main() {27    fmt.Println(validation.IsNumber("123"))28}29import (30func main() {31    fmt.Println(validation.IsAlphaNumeric("test123"))32}33import (

1func main(){2     f.Validate()3}4func main(){5     f.Validate()6}7func main(){8     f.Validate()9}10func main(){11     f.Validate()12}13func main(){14     f.Validate()15}16func main(){17     f.Validate()18}19func main(){20     f.Validate()21}22func main(){23     f.Validate()24}25func main(){26     f.Validate()27}28func main(){29     f.Validate()30}31func main(){32     f.Validate()33}34func main(){35     f.Validate()36}37func main(){38     f.Validate()39}40func main(){41     f.Validate()42}