/**
 * @author higa
 *
 */
public class IntegerConversionUtilTest extends TestCase {

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

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

		return nil, fmt.Errorf("%w: %+v", ErrUnsupportedDataType, dest)
	}

	modelType := reflect.ValueOf(dest).Type()
	if modelType.Kind() == reflect.Ptr {
		modelType = modelType.Elem()
	}

	if modelType.Kind() != reflect.Struct {
		if modelType.Kind() == reflect.Interface {
			modelType = reflect.Indirect(reflect.ValueOf(dest)).Elem().Type()
		}

    @Override
    public SampleElements<BigInteger> samples() {
      return new SampleElements<>(
          BigInteger.valueOf(1),
          BigInteger.valueOf(4),
          BigInteger.valueOf(3),
          BigInteger.valueOf(2),
          BigInteger.valueOf(5));
    }

    @Override
    public BigInteger[] createArray(int length) {
      return new BigInteger[length];
    }

    @Override

										</div>
									</div>
									</c:forEach>
									<c:set var="nameKey">name${Double.valueOf(savedTags.size()/2).intValue()+1}</c:set>
									<c:set var="valueKey">value${Double.valueOf(savedTags.size()/2).intValue()+1}</c:set>
									<div class="form-group row">
										<div class="col-sm-6">

    public BigInteger apply(Integer from) {
      BigInteger v = BigInteger.valueOf(from);
      // Math.sin is very slow for values outside 4*pi
      // Need to take absolute value to avoid inverting the value.
      for (double i = 0; i < 100; i += 20) {
        v =
            v.add(
                v.multiply(
                    BigInteger.valueOf(((Double) Math.abs(Math.sin(i) * 10.0)).longValue())));
      }
      return v;

        .add("ping:  pong  ") // Value whitespace is trimmed.
        .add("kit:kat") // Space after colon is not required.
        .build()
    assertThat(headers.values("foo")).containsExactly("bar", "baz", "bak")
    assertThat(headers.values("key")).containsExactly("value")
    assertThat(headers.values("ping")).containsExactly("pong")
    assertThat(headers.values("kit")).containsExactly("kat")
  }

    // First add all the long candidate values.
    bigValues.addAll(Iterables.transform(POSITIVE_LONG_CANDIDATES, TO_BIGINTEGER));
    // Add boundary values manually to avoid over/under flow.
    bigValues.add(BigInteger.valueOf(Long.MAX_VALUE).add(ONE));
    // Now add values near 2^N for lots of values of N.
    for (int exponent :
        asList(
            64,
            65,

		{"error not equal", errors.New("1"), errors.New("2"), false},
		{"driver.Valuer equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now, Valid: true}, true},
		{"driver.Valuer not equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now.Add(time.Second), Valid: true}, false},
		{"driver.Valuer equal (ptr to nil ptr)", (*ModifyAt)(nil), &ModifyAt{}, false},
	}
	for _, test := range assertEqualTests {

        final MyBean myBean = new MyBean();
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final PropertyDesc propDesc = beanDesc.getPropertyDesc("ggg");
        propDesc.setValue(myBean, Integer.valueOf(1));
        assertThat(myBean.getGgg(), is(new BigDecimal(1)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testSetTimestampValue() throws Exception {

        assertTrue("Should have FILE protocol type", hasFile);
    }

    // Test ProtocolType valueOf
    public void test_protocolTypeValueOf() {
        assertEquals("valueOf(\"WEB\") should return WEB", ProtocolType.WEB, ProtocolType.valueOf("WEB"));
        assertEquals("valueOf(\"FILE\") should return FILE", ProtocolType.FILE, ProtocolType.valueOf("FILE"));
    }

    // Test ProtocolType name
    public void test_protocolTypeName() {