code: /*
  JavadocMethod
  allowedAnnotations = (default)Override
  validateThrows = true
  accessModifiers = (default)public, protected, package, private
  allowMissingParamTags = (default)false
  allowMissingReturnTag = (default)false
  tokens = (default)METHOD_DEF, CTOR_DEF, ANNOTATION_FIELD_DEF, COMPACT_CTOR_DEF
  
  
  */
  
  package com.puppycrawl.tools.checkstyle.checks.javadoc.javadocmethod;
  
  
  
  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.IOException;
  import java.util.Scanner;
  import java.util.function.Function;
  
  public class InputJavadocMethodIgnoreThrows {
  
      /**
       * Ignore try block, but keep catch and finally blocks.
       *
       * @param s String to parse
       * @return A positive integer
       */
      private static int parsePositiveInt(String s) {
          try {
              int value = Integer.parseInt(s);
              if (value <= 0) {
                  throw new NumberFormatException(value + " is negative/zero"); // ok
              }
              return value;
          } catch (NumberFormatException ex) {
              // violation below '.* @throws .* 'IllegalArgumentException'.'
              throw new IllegalArgumentException("Invalid number", ex);
          } finally {
              // violation below '.* @throws .* 'IllegalStateException'.'
              throw new IllegalStateException("Should never reach here");
          }
      }
  
      /**
       * For exceptions that are thrown, caught, and rethrown, violation is in the catch block.
       * Prior to issue 7473, violation was logged in the try block instead.
       *
       * @param o An input
       */
      private static void catchAndRethrow(Object o) {
          try {
              if (o == null) {
                  throw new IllegalArgumentException("null"); // ok, try
              }
          } catch (IllegalArgumentException ex) {
              // violation below '.* @throws .* 'IllegalArgumentException'.'
              throw new IllegalArgumentException(ex.toString());
          }
      }
  
      /**
       * However, rethrowing the same exception (without creating a new one)
       * will not be treated as a violation.
       *
       * @param o An input
       */
      private static void catchAndRethrowSame(Object o) {
          try {
              if (o == null) {
                  throw new IllegalArgumentException("null"); // ok, try
              }
          } catch (IllegalArgumentException ex) {
              throw ex; // no violation
          }
      }
  
      /**
       * It is not possible to tell the exact type of the exception
       * unless 'throw new' is used.
       *
       * @param o An input
       * @param i Another input
       */
      private static void catchAndRethrowDifferent(Object o, int i) {
          try {
              float x = 1 / i; // ArithmeticException when i = 0
          } catch (RuntimeException ex) {
              if (o == null) {
                  ex = new NullPointerException("");
              }
              throw ex; // ok
          }
      }
  
      /**
       * Ignore everything inside lambda.
       *
       * @param maxLength Max length
       * @return A function to truncate string
       */
      private static Function<String, String> getTruncateFunction(int maxLength) {
          return s -> {
              if (s == null) {
                  throw new IllegalArgumentException("Cannot truncate null"); // ok, inside lambda
              }
              return s.length() > maxLength ? s.substring(0, maxLength) : s;
          };
      }
  
      /**
       * Try-with-resources should also be ignored if there is a catch block.
       *
       * @param input file to read
       */
      private static void ignoreTryWithResources(String input) {
          try (BufferedReader in = new BufferedReader(new FileReader(input))) {
              String s = in.readLine();
              System.out.println(s);
              if (s.length() == 0) {
                  // false negative, unable to tell what was caught
                  throw new IllegalArgumentException("empty input"); // no violation
              }
              else {
                  throw new IOException(); // ok, exception was caught
              }
          } catch (IOException e) {
              System.out.println("Error reading file");
          }
      }
  
      /**
       * However, do not ignore try block without catch.
       */
      private static void keepTryWithoutCatch() {
          try (Scanner sc = new Scanner(System.in)) {
              if (sc.nextInt() <= 0) {
                  // violation below '.* @throws .* 'IllegalArgumentException'.'
                  throw new IllegalArgumentException("");
              }
          }
      }
  
      /**
       * Local inner classes should be ignored.
       *
       * @param str input
       */
      void dfs(String str) {
          class DFS {
              void neverCalled() {
                  throw new IllegalStateException(""); // ok, inside local class
              }
  
              void dfs(String str) {
                  if (str != null) {
                      dfs(str.toLowerCase());
                      System.out.println(str);
                      dfs(str.toUpperCase());
                  }
              }
          }
          new DFS().dfs(str);
      }
  
      /**
       * Anonymous classes should be ignored as well.
       *
       * @return some Runnable
       */
      Runnable ignoreAnonClasses() {
          return new Runnable() {
              @Override
              public void run() {
                  throw new UnsupportedOperationException(""); // ok, inside anon class
              }
          };
      }
  
      /**
       * Catch block is not ignored, but lambda is still ignored.
       *
       * @param s a string
       * @return a function
       */
      Function<String, Integer> lambdaInCatchBlock(String s) {
          try {
              int value = Integer.parseInt(s);
              if (value <= 0) {
                  throw new NumberFormatException(value + " is negative/zero"); // ok, try
              }
              return x -> value;
          } catch (NumberFormatException ex) {
              if (s.length() == 1) {
                  // violation below '.* @throws .* 'IllegalArgumentException'.'
                  throw new IllegalArgumentException("Invalid number", ex);
              }
              return x -> {
                  throw new UnsupportedOperationException(""); // ok, inside lambda
              };
          }
      }
  
  }
  