public class NumberConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testConvertNumber_byte() throws Exception {
        assertEquals(new Byte("1"), NumberConversionUtil.convertNumber(Byte.class, "1"));
    }

    /**
     * @throws Exception
     */
    public void testConvertNumber_primitiveWrapper() throws Exception {

            doClose();
        }
        return n;
    }


    /**
     * @throws SmbException
     */
    private void checkStatus () throws SmbException {
        int status = this.response.getStatus();
        if ( status == WinError.ERROR_SERVICE_NOT_INSTALLED ) {
            throw new SmbUnsupportedOperationException();
        }

  }

  @Throws(SocketException::class)
  override fun getSendBufferSize(): Int {
    return delegate!!.sendBufferSize
  }

  @Throws(SocketException::class)
  override fun getSoTimeout(): Int {
    return delegate!!.soTimeout
  }

  @Throws(SocketException::class)
  override fun getTcpNoDelay(): Boolean {
    return delegate!!.tcpNoDelay
  }

  @Throws(SocketException::class)

     * @throws PACDecodingException
     */
    public static <T extends Object> T as ( Class<T> type, Enumeration<?> enumeration ) throws PACDecodingException {
        return as(type, enumeration.nextElement());
    }


    /**
     * 
     * @param type
     * @param stream
     * @return next object from stream cast to type
     * @throws PACDecodingException
     * @throws IOException

    /**
     * @param threadsBefore
     * @param start
     * @param ctx
     * @param f
     * @throws ConnectionTimeoutException
     * @throws SmbException
     */
    void runConnectTimeoutTest ( Set<Thread> threadsBefore, long start, CIFSContext ctx, SmbResource f )
            throws ConnectionTimeoutException, CIFSException {
        try {
            f.createNewFile();

                throw new TransferCancelledException();
            }

            @Override
            public void transferProgressed(TransferEvent event) throws TransferCancelledException {
                throw new TransferCancelledException();
            }

            @Override
            public void transferCorrupted(TransferEvent event) throws TransferCancelledException {

        return input;
      } catch (InterruptedException e) {
        throw new AssertionError();
      }
    }

    @Override
    public void sleepThenThrowException() throws SampleException {
      try {
        MILLISECONDS.sleep(delayMillis);
      } catch (InterruptedException e) {
      }
      throw new SampleException();
    }
  }

    /**
     * @throws Exception
     */
    @Test(expected = IllegalPropertyRuntimeException.class)
    public void testSetValue_notWritable() throws Exception {
        final MyBean myBean = new MyBean();
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final PropertyDesc propDesc = beanDesc.getPropertyDesc("aaa");
        propDesc.setValue(myBean, null);
    }

    /**
     * @throws Exception
     */

        public int type;
        public uuid_t uuid;


        @Override
        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(this.type);
            if ( this.uuid == null )
                throw new NdrException(NdrException.NO_NULL_REF);
            _dst.enc_ndr_long(this.uuid.time_low);
            _dst.enc_ndr_short(this.uuid.time_mid);

            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    /**
     * @param reader a reader object.
     * @throws IOException IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     * any.
     * @return Model
     */
    public Settings read(Reader reader) throws IOException, XmlPullParserException {
        try {