/*
* Copyright 2007 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 com.google.gwt.user.client.rpc.EnumsTestService.Basic;
import com.google.gwt.user.client.rpc.EnumsTestService.Complex;
import com.google.gwt.user.client.rpc.EnumsTestService.FieldEnum;
import com.google.gwt.user.client.rpc.EnumsTestService.FieldEnumWrapper;
import com.google.gwt.user.client.rpc.EnumsTestService.Subclassing;
/**
* Tests enums over RPC.
*/
public class EnumsTest extends RpcTestBase {
private static EnumsTestServiceAsync getService() {
EnumsTestServiceAsync service = GWT.create(EnumsTestService.class);
ServiceDefTarget target = (ServiceDefTarget) service;
target.setServiceEntryPoint(GWT.getModuleBaseURL() + "enums");
return service;
}
private static void rethrowException(Throwable caught) {
if (caught instanceof RuntimeException) {
throw (RuntimeException) caught;
} else {
throw new RuntimeException(caught);
}
}
/**
* Test that basic enums can be used over RPC.
*/
public void testBasicEnums() {
delayTestFinishForRpc();
getService().echo(Basic.A, new AsyncCallback<Basic>() {
@Override
public void onFailure(Throwable caught) {
rethrowException(caught);
}
@Override
public void onSuccess(Basic result) {
assertNotNull("Was null", result);
assertEquals(Basic.A, result);
finishTest();
}
});
}
/**
* Test that complex enums with state and non-default constructors can be used
* over RPC and that the client state does not change.
*/
public void testComplexEnums() {
Complex a = Complex.A;
a.value = "client";
delayTestFinishForRpc();
getService().echo(Complex.A, new AsyncCallback<Complex>() {
@Override
public void onFailure(Throwable caught) {
rethrowException(caught);
}
@Override
public void onSuccess(Complex result) {
assertNotNull("Was null", result);
assertEquals(Complex.A, result);
// Ensure that the server's changes did not impact us.
assertEquals("client", result.value);
finishTest();
}
});
}
/**
* Test that null can be used as an enumeration.
*/
public void testNull() {
delayTestFinishForRpc();
getService().echo((Basic) null, new AsyncCallback<Basic>() {
@Override
public void onFailure(Throwable caught) {
rethrowException(caught);
}
@Override
public void onSuccess(Basic result) {
assertNull(result);
finishTest();
}
});
}
/**
* Test that enums with subclasses can be passed over RPC.
*/
public void testSubclassingEnums() {
delayTestFinishForRpc();
getService().echo(Subclassing.A, new AsyncCallback<Subclassing>() {
@Override
public void onFailure(Throwable caught) {
rethrowException(caught);
}
@Override
public void onSuccess(Subclassing result) {
assertNotNull("Was null", result);
assertEquals(Subclassing.A, result);
finishTest();
}
});
}
/**
* Test that enums as fields in a wrapper class can be passed over RPC.
*/
public void testFieldEnumWrapperClass() {
delayTestFinishForRpc();
FieldEnumWrapper wrapper = new FieldEnumWrapper();
wrapper.setFieldEnum(FieldEnum.X);
getService().echo(wrapper, new AsyncCallback<FieldEnumWrapper>() {
@Override
public void onFailure(Throwable caught) {
rethrowException(caught);
}
@Override
public void onSuccess(FieldEnumWrapper result) {
assertNotNull("Was null", result);
FieldEnum fieldEnum = result.getFieldEnum();
/*
* Don't want to do assertEquals(FieldEnum.X, fieldEnum) here,
* since it will force an implicit upcast on FieldEnum -> Object,
* which will bias the test. We want to assert that the
* EnumOrdinalizer properly prevents ordinalization of FieldEnum.
*/
assertTrue(FieldEnum.X == fieldEnum);
finishTest();
}
});
}
}