2.1/user/test/com/google/gwt/user/client/rpc/ValueTypesTest.java

/*
 * Copyright 2008 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.user.client.rpc;

import com.google.gwt.core.client.GWT;

import java.math.BigDecimal;
import java.math.BigInteger;

/**
 * Test transfer of value types over RPC.
 */
public class ValueTypesTest extends RpcTestBase {

  private ValueTypesTestServiceAsync primitiveTypeTestService;

  public void testBigDecimal_base() {
    assertEcho(new BigDecimal("42"));
  }

  public void testBigDecimal_exponential() {
    assertEcho(new BigDecimal("0.00000000000000000001"));
  }

  public void testBigDecimal_negative() {
    assertEcho(new BigDecimal("-42"));
  }

  public void testBigDecimal_zero() {
    assertEcho(new BigDecimal("0.0"));
  }

  public void testBigInteger_base() {
    assertEcho(new BigInteger("42"));
  }

  public void testBigInteger_exponential() {
    assertEcho(new BigInteger("100000000000000000000"));
  }

  public void testBigInteger_negative() {
    assertEcho(new BigInteger("-42"));
  }

  public void testBigInteger_zero() {
    assertEcho(new BigInteger("0"));
  }

  public void testBoolean_FALSE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_FALSE(false, new AsyncCallback<Boolean>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Boolean result) {
        assertNotNull("Was null", result);
        assertFalse("Should have been false", result.booleanValue());
        finishTest();
      }
    });
  }

  public void testBoolean_TRUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_TRUE(true, new AsyncCallback<Boolean>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Boolean result) {
        assertNotNull(result);
        assertTrue(result.booleanValue());
        finishTest();
      }
    });
  }

  public void testByte() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo((byte) (Byte.MAX_VALUE / (byte) 2), new AsyncCallback<Byte>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Byte result) {
        assertNotNull(result);
        assertEquals(Byte.MAX_VALUE / 2, result.byteValue());
        finishTest();
      }
    });
  }

  public void testByte_MAX_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MAX_VALUE(Byte.MAX_VALUE, new AsyncCallback<Byte>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Byte result) {
        assertNotNull(result);
        assertEquals(Byte.MAX_VALUE, result.byteValue());
        finishTest();
      }
    });
  }

  public void testByte_MIN_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MIN_VALUE(Byte.MIN_VALUE, new AsyncCallback<Byte>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Byte result) {
        assertNotNull(result);
        assertEquals(Byte.MIN_VALUE, result.byteValue());
        finishTest();
      }
    });
  }

  public void testChar() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    final char value = (char) (Character.MAX_VALUE / (char) 2);
    service.echo(value, new AsyncCallback<Character>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Character result) {
        assertNotNull(result);
        assertEquals(value, result.charValue());
        finishTest();
      }
    });
  }

  public void testChar_MAX_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MAX_VALUE(Character.MAX_VALUE, new AsyncCallback<Character>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Character result) {
        assertNotNull(result);
        assertEquals(Character.MAX_VALUE, result.charValue());
        finishTest();
      }
    });
  }

  public void testChar_MIN_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MIN_VALUE(Character.MIN_VALUE, new AsyncCallback<Character>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Character result) {
        assertNotNull(result);
        assertEquals(Character.MIN_VALUE, result.charValue());
        finishTest();
      }
    });
  }

  public void testDouble() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Double.MAX_VALUE / 2, new AsyncCallback<Double>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Double result) {
        assertNotNull(result);
        assertEquals(Double.MAX_VALUE / 2, result.doubleValue(), 0.0);
        finishTest();
      }
    });
  }

  public void testDouble_MAX_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MAX_VALUE(Double.MAX_VALUE, new AsyncCallback<Double>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Double result) {
        assertNotNull(result);
        assertEquals(Double.MAX_VALUE, result.doubleValue(), 0.0);
        finishTest();
      }
    });
  }

  public void testDouble_MIN_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MIN_VALUE(Double.MIN_VALUE, new AsyncCallback<Double>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Double result) {
        assertNotNull(result);
        assertEquals(Double.MIN_VALUE, result.doubleValue(), 0.0);
        finishTest();
      }
    });
  }

  /**
   * Validate that NaNs (not-a-number, such as 0/0) propagate properly via RPC.
   */
  public void testDouble_NaN() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Double.NaN, new AsyncCallback<Double>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Double result) {
        assertNotNull(result);
        assertTrue(Double.isNaN(result.doubleValue()));
        finishTest();
      }
    });
  }

  /**
   * Validate that negative infinity propagates properly via RPC.
   */
  public void testDouble_NegInfinity() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Double.NEGATIVE_INFINITY, new AsyncCallback<Double>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Double result) {
        assertNotNull(result);
        double doubleValue = result.doubleValue();
        assertTrue(Double.isInfinite(doubleValue) && doubleValue < 0);
        finishTest();
      }
    });
  }

  /**
   * Validate that positive infinity propagates properly via RPC.
   */
  public void testDouble_PosInfinity() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Double.POSITIVE_INFINITY, new AsyncCallback<Double>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Double result) {
        assertNotNull(result);
        double doubleValue = result.doubleValue();
        assertTrue(Double.isInfinite(doubleValue) && doubleValue > 0);
        finishTest();
      }
    });
  }

  public void testFloat() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Float.MAX_VALUE / 2, new AsyncCallback<Float>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Float result) {
        assertNotNull(result);
        assertEquals(Float.MAX_VALUE / 2, result.floatValue(), 0.0);
        finishTest();
      }
    });
  }

  public void testFloat_MAX_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MAX_VALUE(Float.MAX_VALUE, new AsyncCallback<Float>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Float result) {
        assertNotNull(result);
        assertEquals(Float.MAX_VALUE, result.floatValue(), 0.0);
        finishTest();
      }
    });
  }

  public void testFloat_MIN_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MIN_VALUE(Float.MIN_VALUE, new AsyncCallback<Float>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Float result) {
        assertNotNull(result);
        assertEquals(Float.MIN_VALUE, result.floatValue(), 0.0);
        finishTest();
      }
    });
  }

  /**
   * Validate that NaNs (not-a-number, such as 0/0) propagate properly via RPC.
   */
  public void testFloat_NaN() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Float.NaN, new AsyncCallback<Float>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Float result) {
        assertNotNull(result);
        assertTrue(Float.isNaN(result.floatValue()));
        finishTest();
      }
    });
  }

  /**
   * Validate that negative infinity propagates properly via RPC.
   */
  public void testFloat_NegInfinity() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Float.NEGATIVE_INFINITY, new AsyncCallback<Float>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Float result) {
        assertNotNull(result);
        float floatValue = result.floatValue();
        assertTrue(Float.isInfinite(floatValue) && floatValue < 0);
        finishTest();
      }
    });
  }

  /**
   * Validate that positive infinity propagates properly via RPC.
   */
  public void testFloat_PosInfinity() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Float.POSITIVE_INFINITY, new AsyncCallback<Float>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Float result) {
        assertNotNull(result);
        float floatValue = result.floatValue();
        assertTrue(Float.isInfinite(floatValue) && floatValue > 0);
        finishTest();
      }
    });
  }

  public void testInteger() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Integer.MAX_VALUE / 2, new AsyncCallback<Integer>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Integer result) {
        assertNotNull(result);
        assertEquals(Integer.MAX_VALUE / 2, result.intValue());
        finishTest();
      }
    });
  }

  public void testInteger_MAX_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MAX_VALUE(Integer.MAX_VALUE, new AsyncCallback<Integer>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Integer result) {
        assertNotNull(result);
        assertEquals(Integer.MAX_VALUE, result.intValue());
        finishTest();
      }
    });
  }

  public void testInteger_MIN_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MIN_VALUE(Integer.MIN_VALUE, new AsyncCallback<Integer>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Integer result) {
        assertNotNull(result);
        assertEquals(Integer.MIN_VALUE, result.intValue());
        finishTest();
      }
    });
  }

  public void testLong() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(Long.MAX_VALUE / 2, new AsyncCallback<Long>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Long result) {
        assertNotNull(result);
        long expected = Long.MAX_VALUE / 2;
        assertEquals(expected, result.longValue());
        finishTest();
      }
    });
  }

  public void testLong_MAX_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MAX_VALUE(Long.MAX_VALUE, new AsyncCallback<Long>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Long result) {
        assertNotNull(result);
        assertEquals(Long.MAX_VALUE, result.longValue());
        finishTest();
      }
    });
  }

  public void testLong_MIN_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MIN_VALUE(Long.MIN_VALUE, new AsyncCallback<Long>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Long result) {
        assertNotNull(result);
        assertEquals(Long.MIN_VALUE, result.longValue());
        finishTest();
      }
    });
  }

  public void testShort() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    final short value = (short) (Short.MAX_VALUE / 2);
    service.echo(value , new AsyncCallback<Short>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Short result) {
        assertNotNull(result);
        assertEquals(value, result.shortValue());
        finishTest();
      }
    });
  }

  public void testShort_MAX_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MAX_VALUE(Short.MAX_VALUE, new AsyncCallback<Short>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Short result) {
        assertNotNull(result);
        assertEquals(Short.MAX_VALUE, result.shortValue());
        finishTest();
      }
    });
  }

  public void testShort_MIN_VALUE() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo_MIN_VALUE(Short.MIN_VALUE, new AsyncCallback<Short>() {

      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(Short result) {
        assertNotNull(result);
        assertEquals(Short.MIN_VALUE, result.shortValue());
        finishTest();
      }
    });
  }

  public void testVoidParameterizedType() {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(new SerializableGenericWrapperType<Void>(),
        new AsyncCallback<SerializableGenericWrapperType<Void>>() {

          public void onFailure(Throwable caught) {
            TestSetValidator.rethrowException(caught);
          }

          public void onSuccess(SerializableGenericWrapperType<Void> result) {
            assertNotNull(result);
            assertNull(result.getValue());
            finishTest();
          }
        });
  }
  
  private void assertEcho(final BigDecimal value) {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(value, new AsyncCallback<BigDecimal>() {
      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(BigDecimal result) {
        assertEquals(value, result);
        finishTest();
      }
    });
  }

  private void assertEcho(final BigInteger value) {
    ValueTypesTestServiceAsync service = getServiceAsync();
    delayTestFinishForRpc();
    service.echo(value, new AsyncCallback<BigInteger>() {
      public void onFailure(Throwable caught) {
        TestSetValidator.rethrowException(caught);
      }

      public void onSuccess(BigInteger result) {
        assertEquals(value, result);
        finishTest();
      }
    });
  }

  private ValueTypesTestServiceAsync getServiceAsync() {
    if (primitiveTypeTestService == null) {
      primitiveTypeTestService = (ValueTypesTestServiceAsync) GWT.create(ValueTypesTestService.class);
      ((ServiceDefTarget) primitiveTypeTestService).setServiceEntryPoint(GWT.getModuleBaseURL()
          + "valuetypes");
    }
    return primitiveTypeTestService;
  }
}