- name: GitHub CODEOWNERS Validator
        uses: mszostok/codeowners-validator@v0.7.4
        with:
          checks: "files,duppatterns,syntax"
          experimental_checks: "notowned,avoid-shadowing"

      # downgrading to 0.7.2 for owners check to avoid issues with token permissions check,
      # see https://github.com/mszostok/codeowners-validator/issues/224
      - name: GitHub CODEOWNERS Validator

        }
    }

    /**
     * Validates a string is not null or empty
     *
     * @param value the string to validate
     * @param fieldName the field name for error reporting
     * @return the validated string
     * @throws IllegalArgumentException if string is null or empty
     */

	}
	return ""
}

// Validate - validates the rule element
func (r Rule) Validate(bucket string, sameTarget bool) error {
	if err := r.validateID(); err != nil {
		return err
	}
	if err := r.validateStatus(); err != nil {
		return err
	}
	if err := r.validateFilter(); err != nil {
		return err
	}
	if err := r.DeleteMarkerReplication.Validate(); err != nil {
		return err
	}

        SimpleProblemCollector result = validate("missing-artifactId-pom.xml");

        assertViolations(result, 0, 1, 0);

        assertEquals("'artifactId' is missing.", result.getErrors().get(0));
    }

    @Test
    void testMissingGroupId() throws Exception {
        SimpleProblemCollector result = validate("missing-groupId-pom.xml");

        assertViolations(result, 0, 1, 0);

    validate();
    return delegate;
  }

  private InvalidatableSet(
      Set<E> delegate, Supplier<Boolean> validator, Supplier<String> errorMessage) {
    this.delegate = delegate;
    this.validator = validator;
    this.errorMessage = errorMessage;
  }

  // Override hashCode() to access delegate directly (so that it doesn't trigger the validate() call
  // via delegate()); it seems inappropriate to throw ISE on this method.

    private final AtomicLong bufferOverflowsPrevented = new AtomicLong(0);
    private final AtomicLong integerOverflowsPrevented = new AtomicLong(0);

    /**
     * Validate SMB response buffer bounds
     *
     * @param buffer the buffer to validate
     * @param expectedSize expected minimum size
     * @param maxSize maximum allowed size
     * @throws SmbException if validation fails
     */

	var tmp retry
	err := val.Decode(&tmp)
	if err != nil {
		return err
	}

	*r = BatchJobRetry(tmp)
	r.line, r.col = val.Line, val.Column
	return nil
}

// Validate validates input replicate retries.
func (r BatchJobRetry) Validate() error {
	if r.Attempts < 0 {
		return BatchJobYamlErr{
			line: r.line,
			col:  r.col,
			msg:  "Invalid arguments specified",
		}
	}

	if r.Delay < 0 {

	}
	if err := r.Encryption.Validate(); err != nil {
		return err
	}

	for _, tag := range r.Flags.Filter.Tags {
		if err := tag.Validate(); err != nil {
			return err
		}
	}

	for _, meta := range r.Flags.Filter.Metadata {
		if err := meta.Validate(); err != nil {
			return err
		}
	}

	return r.Flags.Retry.Validate()

			if buf.Len() > 0 {
				buf.WriteString("&")
			}
			buf.WriteString(t.String())
		}
		return buf.String()
	}
	return ""
}

// Validate - validates the rule element
func (r Rule) Validate() error {
	if err := r.validateID(); err != nil {
		return err
	}
	if err := r.validateStatus(); err != nil {
		return err
	}
	if err := r.validateExpiration(); err != nil {
		return err
	}

        this.strictMode = strictMode;
        this.blacklistedPaths = new HashSet<>();
        this.whitelistedPaths = new HashSet<>();
    }

    /**
     * Validate and normalize a path
     *
     * @param path the path to validate
     * @return normalized safe path
     * @throws SmbException if path is invalid or dangerous
     */
    public String validatePath(String path) throws SmbException {