throw t;
    }
  }

  /** Calls threadFail with message "should throw exception". */
  public void threadShouldThrow() {
    threadFail("should throw exception");
  }

  /** Calls threadFail with message "should throw" + exceptionName. */
  public void threadShouldThrow(String exceptionName) {
    threadFail("should throw " + exceptionName);
  }

  /**

    return FS.getRootDirectories().iterator().next();
  }

  private Path tempDir;

  @Override
  protected void setUp() throws Exception {
    tempDir = Files.createTempDirectory("MoreFilesTest");
  }

  @Override
  protected void tearDown() throws Exception {
    if (tempDir != null) {
      // delete tempDir and its contents
      Files.walkFileTree(
          tempDir,

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 {

  }

  @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)

                throw new TransferCancelledException();
            }

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

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

    /**
     * @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
     */

            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 {

  /** Throws an undeclared checked exception. */
  private static void sneakyThrow(Throwable t) {
    class SneakyThrower<T extends Throwable> {
      @SuppressWarnings("unchecked") // intentionally unsafe for test
      void throwIt(Throwable t) throws T {
        throw (T) t;
      }
    }
    new SneakyThrower<Error>().throwIt(t);
  }

        throw new UnsupportedOperationException("Cannot get available versions in this test case");
    }

    public List<ArtifactVersion> retrieveAvailableVersionsFromDeploymentRepository(
            Artifact artifact, ArtifactRepository localRepository, ArtifactRepository remoteRepository)
            throws ArtifactMetadataRetrievalException {

    }

    @Override
    public void addRepository(Repository repository) throws InvalidRepositoryException {
        addRepository(repository, false);
    }

    @Override
    public void addRepository(final Repository repository, boolean replace) throws InvalidRepositoryException {
        if (session.isIgnoreArtifactDescriptorRepositories()) {
            return;
        }