public static void assertArgumentArrayIndex(final String argName, final int argValue, final int arraySize) {
        if (argValue < 0) {
            throw new ClIllegalArgumentException(argName, "ECL0014", asArray(argName));
        }
        if (argValue >= arraySize) {
            throw new ClIllegalArgumentException(argName, "ECL0015", asArray(argName, arraySize));
        }
    }

    /**
     * 引数が不正でないことを表明します。
     *

                case SmbComTransaction.TRANS2_GET_DFS_REFERRAL:
                    break;
                default:
                    throw new SmbException("Invalid operation for " + svc + " service: " + request);
                }
                break;
            default:
                throw new SmbException("Invalid operation for " + svc + " service" + request);
            }
        }
    }

            }
        } catch (ClientProtocolException e) {
            throw wrap(e.getCause());
        } catch (IOException e) {
            throw wrap(e);
        }
    }

    private static BuildCacheException wrap(Throwable e) {
        if (e instanceof Error) {
            throw (Error) e;
        }

        throw new BuildCacheException(e.getMessage(), e);
    }

        } catch (IOException e) {
            throw ResourceExceptions.getFailed(getURI(), e);
        }
    }

    @Override
    public ExternalResourceReadResult<Void> withContent(Action<? super InputStream> readAction) {
        if (!localFile.exists()) {
            throw ResourceExceptions.getMissing(getURI());
        }
        try {

        if (options.getMode() == LockMode.OnDemand) {
            throw new UnsupportedOperationException(String.format("No %s mode lock implementation available.", options));
        }
        File canonicalTarget;
        try {
            canonicalTarget = target.getCanonicalFile();
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
        if (!lockedFiles.add(canonicalTarget)) {

          @Override
          public Integer computeNext() {
            if (haveBeenCalled) {
              throw new AssertionError("Should not have been called again");
            } else {
              haveBeenCalled = true;
              sneakyThrow(new SomeCheckedException());
              throw new AssertionError(); // unreachable
            }
          }
        };

        throw new UnsupportedOperationException();
    }

    @Override
    public void fireTestRunFinished(Result result) {
        // Not meant to be called by a client
        throw new UnsupportedOperationException();
    }

    @Override
    public void addFirstListener(RunListener listener) {
        // Not meant to be called by a client
        throw new UnsupportedOperationException();
    }

        if ( token.length <= 0 )
            throw new PACDecodingException("Empty kerberos ticket");

        ASN1Sequence sequence;
        try {
            try ( ASN1InputStream stream = new ASN1InputStream(new ByteArrayInputStream(token)) ) {
                sequence = ASN1Util.as(ASN1Sequence.class, stream);
            }
        }
        catch ( IOException e ) {
            throw new PACDecodingException("Malformed kerberos ticket", e);

        }

        @Override
        Provider<String> getBaseName() {
            throw new UnsupportedOperationException()
        }

        @Override
        boolean isDebuggable() {
            throw new UnsupportedOperationException()
        }

        @Override
        boolean isOptimized() {
            throw new UnsupportedOperationException()
        }

        @Override

    if (key == null) {
      throw new NullPointerException("null key in entry: null=" + value);
    } else if (value == null) {
      throw new NullPointerException("null value in entry: " + key + "=null");
    }
  }

  @CanIgnoreReturnValue
  static int checkNonnegative(int value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);