public int encode ( byte[] dst, int dstIndex ) {
        int len = super.encode(dst, dstIndex);
        int exp = size();
        int actual = getLength();
        if ( exp != actual ) {
            throw new IllegalStateException(String.format("Wrong size calculation have %d expect %d", exp, actual));
        }
        return len;
    }


    /**
     * {@inheritDoc}
     *

        final BulkItemResponse[] itemResponses = response.getItems();
        if (itemResponses.length != entityList.size()) {
            throw new IllegalStateException("Invalid response size: " + itemResponses.length + " != " + entityList.size());
        }
        final int[] results = new int[itemResponses.length];
        for (int i = 0; i < itemResponses.length; i++) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.exception;

/**
 * {@link IllegalStateException}をラップする例外です。
 *
 * @author wyukawa
 */
public class ClIllegalStateException extends IllegalStateException {

    private static final long serialVersionUID = -2154525994315946504L;

    /**
     * {@link ClIllegalStateException}を作成します。
     */

            }
            der.writeObject(new DERTaggedObject(true, 1, new DERSequence(fields)));
            return collector.toByteArray();
        }
        catch ( IOException ex ) {
            throw new IllegalStateException(ex.getMessage());
        }
    }


    @Override
    protected void parse ( byte[] token ) throws IOException {
        try ( ASN1InputStream der = new ASN1InputStream(token) ) {

            der.writeObject(derApplicationSpecific);
            return collector.toByteArray();
        }
        catch ( IOException ex ) {
            throw new IllegalStateException(ex.getMessage());
        }
    }


    @Override
    protected void parse ( byte[] token ) throws IOException {

        try ( ASN1InputStream is = new ASN1InputStream(token) ) {

     */
    public static void setURLStreamHandlerFactory ( URLStreamHandlerFactory factory ) {
        synchronized ( PROTOCOL_HANDLERS ) {
            if ( Handler.factory != null ) {
                throw new IllegalStateException("URLStreamHandlerFactory already set.");
            }
            PROTOCOL_HANDLERS.clear();
            Handler.factory = factory;
        }
    }


    /**
     * @param tc

                writeSecurityBuffer(type1, 24, 32 + domain.length, workstation);
            }
            return type1;
        } catch (IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    public String toString() {
        String suppliedDomain = getSuppliedDomain();
        String suppliedWorkstation = getSuppliedWorkstation();

     * このクラスをロードしたクラスローダを返します。
     * </p>
     *
     * @param targetClass
     *            ターゲット・クラス。{@literal null}であってはいけません
     * @return クラスローダ
     * @throws IllegalStateException
     *             クラスローダを取得できなかった場合
     */
    public static ClassLoader getClassLoader(final Class<?> targetClass) {
        assertArgumentNotNull("targetClass", targetClass);

         */
        public Integer echo(final Integer arg) {
            return arg;
        }

        /**
         *
         */
        public void throwException() {
            throw new IllegalStateException("hoge");
        }
    }

    /**
     *
     */
    public class MyBean2 {
        /**
         *
         */
        public MyBean2() {
        }

        /**

            ipad[i] = IPAD;
            opad[i] = OPAD;
        }
        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (Exception ex) {
            throw new IllegalStateException(ex.getMessage());
        }
        engineReset();
    }

    private HMACT64(HMACT64 hmac) throws CloneNotSupportedException {
        super("HMACT64");
        this.ipad = hmac.ipad;