*
 */
public class ByteConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToByte() throws Exception {
        assertEquals(new Byte("100"), ByteConversionUtil.toByte("100"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveByte() throws Exception {
        assertEquals(100, ByteConversionUtil.toPrimitiveByte("100"));
    }

 *
 */
public class DoubleConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToDouble() throws Exception {
        assertEquals(new Double("1000.5"), DoubleConversionUtil.toDouble("1,000.5"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveDouble() throws Exception {
        assertEquals(1000.5, DoubleConversionUtil.toPrimitiveDouble("1,000.5"), 0);

 *
 */
public class FloatConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToFloat() throws Exception {
        assertEquals(new Float("1000.5"), FloatConversionUtil.toFloat("1,000.5"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveFloat() throws Exception {
        assertEquals(1000.5, FloatConversionUtil.toPrimitiveFloat("1,000.5"), 0);

 *
 */
public class IntegerConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToInteger() throws Exception {
        assertEquals(new Integer("1000"), IntegerConversionUtil.toInteger("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveInt() throws Exception {
        assertEquals(1000, IntegerConversionUtil.toPrimitiveInt("1,000"));
    }

      monitor.leave();
    }
  }

  /**
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */
  @CanIgnoreReturnValue
  @Override
  public int drainTo(Collection<? super E> c) {
    if (c == null) throw new NullPointerException();

    public LockState markDirty(LockState lockState) throws IOException {
        LockState newState = lockState.beforeUpdate();
        lockStateAccess.writeState(lockFileAccess, newState);
        return newState;
    }

    public void clearLockInfo() throws IOException {
        lockInfoAccess.clearLockInfo(lockFileAccess);
    }

    public FileLockOutcome tryLockInfo(boolean shared) throws IOException {

        throw new UnsupportedOperationException();
    }

    @Override
    public void upload(ReadableContent resource, ExternalResourceName destination) throws IOException {
        throw new UnsupportedOperationException();
    }

static final String ROLE; public abstract Object lookup(String) throws component.repository.exception.ComponentLookupExcep; public abstract Object lookup(String, classworlds.realm.ClassRealm) throws component.repository.exception.ComponentLookupExcep; public abstract Object lookup(String, String) throws component.repository.exception.ComponentLookupExcep; public abstract Object lookup(String, String, classworlds.realm.ClassRealm) throws component.repository.exception.ComponentLookupExcep; public abstract...

    private Model read(String pom) throws Exception {
        String resource = "/poms/validation/" + pom;
        try (InputStream is = getClass().getResourceAsStream(resource)) {
            assertNotNull(is, "missing resource: " + resource);
            return new Model(new MavenStaxReader().read(is));
        }
    }

    private SimpleProblemCollector validate(String pom) throws Exception {

        public abstract void encode(Encoder encoder, Object array) throws IOException;

        public abstract Object decode(Decoder decoder) throws IOException;

        public static PrimitiveType of(Class<?> arrayType) {
            PrimitiveType primitiveType = maybeOf(arrayType);
            if (primitiveType == null) {
                throw new ValueSnapshottingException("Unsupported primitive array type: " + arrayType);