| /* |
| * 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.dev.jjs.test; |
| |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.junit.client.GWTTestCase; |
| |
| /** |
| * Test comparison of various types of objects under various circumstances. Its |
| * main purpose is to ensure that identity comparisons work properly whether |
| * object values are null, non-null, or undefined (which is now being treated as |
| * equivalent to null); and also ensure no String equality comparisons occur. |
| */ |
| public class ObjectIdentityTest extends GWTTestCase { |
| |
| /** |
| * An object that toString()s to a given value, used to ensure String equality |
| * is never used inappropriately. |
| */ |
| private static class Foo { |
| private String s; |
| |
| public Foo(String s) { |
| this.s = s; |
| } |
| |
| @Override |
| public String toString() { |
| return s; |
| } |
| } |
| |
| private static volatile boolean TRUE = true; |
| |
| /* |
| * Using volatile to ensure that the compiler is unsure about null-ness. |
| */ |
| private volatile String maybeNullStringIsNull = null; |
| private volatile Object maybeNullObjectIsNull = null; |
| private volatile Foo maybeNullFooIsNull = null; |
| private Object maybeNullTightenStringIsNull = maybeNullStringIsNull; |
| private Object maybeNullTightenFooIsNull = maybeNullFooIsNull; |
| |
| private volatile String maybeNullStringIsUndefined = undefinedString(); |
| private volatile Object maybeNullObjectIsUndefined = undefinedObject(); |
| private volatile Foo maybeNullFooIsUndefined = undefinedFoo(); |
| private Object maybeNullTightenStringIsUndefined = maybeNullStringIsUndefined; |
| private Object maybeNullTightenFooIsUndefined = maybeNullFooIsUndefined; |
| |
| private String notNullString = "foo"; |
| private String notNullStringOther = "bar"; |
| private Object notNullObject = TRUE ? new Foo(notNullString) : new Object(); |
| private Object notNullObjectOther = TRUE ? new Foo(notNullStringOther) |
| : new Object(); |
| private Foo notNullFoo = new Foo(notNullString); |
| private Foo notNullFooOther = new Foo(notNullStringOther); |
| private Object notNullTightenString = notNullString; |
| private Object notNullTightenFoo = notNullFoo; |
| |
| private volatile String maybeNullString = notNullString; |
| private volatile String maybeNullStringOther = notNullStringOther; |
| private volatile Object maybeNullObject = notNullObject; |
| private volatile Object maybeNullObjectOther = notNullObjectOther; |
| private volatile Foo maybeNullFoo = notNullFoo; |
| private volatile Foo maybeNullFooOther = notNullFooOther; |
| private Object maybeNullTightenString = maybeNullString; |
| private Object maybeNullTightenFoo = maybeNullFoo; |
| |
| @Override |
| public String getModuleName() { |
| return "com.google.gwt.dev.jjs.CompilerSuite"; |
| } |
| |
| @SuppressWarnings("SelfEquality") |
| public void test_MaybeNullFoo_MaybeNullFoo() { |
| assertTrue(maybeNullFoo == maybeNullFoo); |
| assertTrue(maybeNullFoo != maybeNullFooOther); |
| assertTrue(maybeNullFooIsNull != maybeNullFoo); |
| assertTrue(maybeNullFooIsUndefined != maybeNullFoo); |
| assertTrue(maybeNullFooIsNull == maybeNullFooIsUndefined); |
| assertTrue(maybeNullFooIsUndefined == maybeNullFooIsNull); |
| } |
| |
| public void test_MaybeNullFoo_MaybeNullObject() { |
| assertTrue(maybeNullFoo != maybeNullObject); |
| assertTrue(maybeNullFooIsNull != maybeNullObject); |
| assertTrue(maybeNullFooIsUndefined != maybeNullObject); |
| assertTrue(maybeNullFooIsNull == maybeNullObjectIsNull); |
| assertTrue(maybeNullFooIsNull == maybeNullObjectIsUndefined); |
| assertTrue(maybeNullFooIsUndefined == maybeNullObjectIsNull); |
| assertTrue(maybeNullFooIsUndefined == maybeNullObjectIsUndefined); |
| } |
| |
| public void test_MaybeNullFoo_MaybeNullString() { |
| assertTrue(maybeNullFoo != maybeNullTightenString); |
| assertTrue(maybeNullFooIsNull != maybeNullTightenString); |
| assertTrue(maybeNullFooIsUndefined != maybeNullTightenString); |
| assertTrue(maybeNullFooIsNull == maybeNullTightenStringIsNull); |
| assertTrue(maybeNullFooIsNull == maybeNullTightenStringIsUndefined); |
| assertTrue(maybeNullFooIsUndefined == maybeNullTightenStringIsNull); |
| assertTrue(maybeNullFooIsUndefined == maybeNullTightenStringIsUndefined); |
| } |
| |
| public void test_MaybeNullFoo_NotNullFoo() { |
| assertTrue(maybeNullFoo == notNullFoo); |
| assertTrue(maybeNullFoo != notNullFooOther); |
| assertTrue(maybeNullFooIsNull != notNullFoo); |
| assertTrue(maybeNullFooIsUndefined != notNullFoo); |
| } |
| |
| public void test_MaybeNullFoo_NotNullObject() { |
| assertTrue(maybeNullFoo != notNullObject); |
| assertTrue(maybeNullFooIsNull != notNullObject); |
| assertTrue(maybeNullFooIsUndefined != notNullObject); |
| } |
| |
| public void test_MaybeNullFoo_NotNullString() { |
| assertTrue(maybeNullFoo != notNullTightenString); |
| assertTrue(maybeNullFooIsNull != notNullTightenString); |
| assertTrue(maybeNullFooIsUndefined != notNullTightenString); |
| } |
| |
| public void test_MaybeNullFoo_null() { |
| assertTrue(maybeNullFoo != null); |
| assertTrue(maybeNullFooIsNull == null); |
| assertTrue(maybeNullFooIsUndefined == null); |
| } |
| |
| public void test_MaybeNullObject_MaybeNullFoo() { |
| assertTrue(maybeNullObject != maybeNullFoo); |
| assertTrue(maybeNullObjectIsNull != maybeNullFoo); |
| assertTrue(maybeNullObjectIsUndefined != maybeNullFoo); |
| assertTrue(maybeNullObjectIsNull == maybeNullFooIsNull); |
| assertTrue(maybeNullObjectIsNull == maybeNullFooIsUndefined); |
| assertTrue(maybeNullObjectIsUndefined == maybeNullFooIsNull); |
| assertTrue(maybeNullObjectIsUndefined == maybeNullFooIsUndefined); |
| } |
| |
| @SuppressWarnings("SelfEquality") |
| public void test_MaybeNullObject_MaybeNullObject() { |
| assertTrue(maybeNullObject == maybeNullObject); |
| assertTrue(maybeNullObject != maybeNullObjectOther); |
| assertTrue(maybeNullObjectIsNull != maybeNullObject); |
| assertTrue(maybeNullObjectIsUndefined != maybeNullObject); |
| assertTrue(maybeNullObjectIsNull == maybeNullObjectIsUndefined); |
| assertTrue(maybeNullObjectIsUndefined == maybeNullObjectIsNull); |
| } |
| |
| public void test_MaybeNullObject_MaybeNullString() { |
| assertTrue(maybeNullObject != maybeNullString); |
| assertTrue(maybeNullObjectIsNull != maybeNullString); |
| assertTrue(maybeNullObjectIsUndefined != maybeNullString); |
| assertTrue(maybeNullObjectIsNull == maybeNullStringIsNull); |
| assertTrue(maybeNullObjectIsNull == maybeNullStringIsUndefined); |
| assertTrue(maybeNullObjectIsUndefined == maybeNullStringIsNull); |
| assertTrue(maybeNullObjectIsUndefined == maybeNullStringIsUndefined); |
| } |
| |
| public void test_MaybeNullObject_NotNullFoo() { |
| assertTrue(maybeNullObject != notNullFoo); |
| assertTrue(maybeNullObjectIsNull != notNullFoo); |
| assertTrue(maybeNullObjectIsUndefined != notNullFoo); |
| } |
| |
| public void test_MaybeNullObject_NotNullObject() { |
| assertTrue(maybeNullObject == notNullObject); |
| assertTrue(maybeNullObjectIsNull != notNullObject); |
| assertTrue(maybeNullObjectIsUndefined != notNullObject); |
| } |
| |
| public void test_MaybeNullObject_NotNullString() { |
| assertTrue(maybeNullObject != notNullString); |
| assertTrue(maybeNullObjectIsNull != notNullString); |
| assertTrue(maybeNullObjectIsUndefined != notNullString); |
| } |
| |
| public void test_MaybeNullObject_null() { |
| assertTrue(maybeNullObject != null); |
| assertTrue(maybeNullObjectIsNull == null); |
| assertTrue(maybeNullObjectIsUndefined == null); |
| } |
| |
| public void test_MaybeNullString_MaybeNullFoo() { |
| assertTrue(maybeNullString != maybeNullTightenFoo); |
| assertTrue(maybeNullStringIsNull != maybeNullTightenFoo); |
| assertTrue(maybeNullStringIsUndefined != maybeNullTightenFoo); |
| assertTrue(maybeNullStringIsNull == maybeNullTightenFooIsNull); |
| assertTrue(maybeNullStringIsNull == maybeNullTightenFooIsUndefined); |
| assertTrue(maybeNullStringIsUndefined == maybeNullTightenFooIsNull); |
| assertTrue(maybeNullStringIsUndefined == maybeNullTightenFooIsUndefined); |
| } |
| |
| public void test_MaybeNullString_MaybeNullObject() { |
| assertTrue(maybeNullString != maybeNullObject); |
| assertTrue(maybeNullStringIsNull != maybeNullObject); |
| assertTrue(maybeNullStringIsUndefined != maybeNullObject); |
| assertTrue(maybeNullStringIsUndefined == maybeNullObjectIsNull); |
| assertTrue(maybeNullStringIsUndefined == maybeNullObjectIsUndefined); |
| assertTrue(maybeNullStringIsUndefined == maybeNullObjectIsNull); |
| assertTrue(maybeNullStringIsUndefined == maybeNullObjectIsUndefined); |
| } |
| |
| @SuppressWarnings("SelfEquality") |
| public void test_MaybeNullString_MaybeNullString() { |
| assertTrue(maybeNullString == maybeNullString); |
| assertTrue(maybeNullString != maybeNullStringOther); |
| assertTrue(maybeNullStringIsNull != maybeNullString); |
| assertTrue(maybeNullStringIsUndefined != maybeNullString); |
| assertTrue(maybeNullStringIsNull == maybeNullStringIsNull); |
| assertTrue(maybeNullStringIsNull == maybeNullStringIsUndefined); |
| assertTrue(maybeNullStringIsUndefined == maybeNullStringIsNull); |
| assertTrue(maybeNullStringIsUndefined == maybeNullStringIsUndefined); |
| } |
| |
| public void test_MaybeNullString_NotNullFoo() { |
| assertTrue(maybeNullString != notNullTightenFoo); |
| assertTrue(maybeNullStringIsNull != notNullTightenFoo); |
| assertTrue(maybeNullStringIsUndefined != notNullTightenFoo); |
| } |
| |
| public void test_MaybeNullString_NotNullObject() { |
| assertTrue(maybeNullString != notNullObject); |
| assertTrue(maybeNullStringIsNull != notNullObject); |
| assertTrue(maybeNullStringIsUndefined != notNullObject); |
| } |
| |
| public void test_MaybeNullString_NotNullString() { |
| assertTrue(maybeNullString == notNullString); |
| assertTrue(maybeNullStringIsNull != notNullString); |
| assertTrue(maybeNullStringIsUndefined != notNullString); |
| } |
| |
| public void test_MaybeNullString_null() { |
| assertTrue(maybeNullString != null); |
| assertTrue(maybeNullStringIsNull == null); |
| assertTrue(maybeNullStringIsUndefined == null); |
| } |
| |
| @SuppressWarnings("SelfEquality") |
| public void test_NotNullFoo_NotNullFoo() { |
| assertTrue(notNullFoo == notNullFoo); |
| assertTrue(notNullFoo != notNullFooOther); |
| } |
| |
| public void test_NotNullFoo_NotNullObject() { |
| assertTrue(notNullFoo != notNullObject); |
| } |
| |
| public void test_NotNullFoo_NotNullString() { |
| assertTrue(notNullFoo != notNullTightenString); |
| } |
| |
| public void test_NotNullFoo_null() { |
| assertTrue(notNullFoo != null); |
| } |
| |
| public void test_NotNullObject_NotNullFoo() { |
| assertTrue(notNullObject != notNullFoo); |
| } |
| |
| @SuppressWarnings("SelfEquality") |
| public void test_NotNullObject_NotNullObject() { |
| assertTrue(notNullObject == notNullObject); |
| assertTrue(notNullObject != notNullObjectOther); |
| } |
| |
| public void test_NotNullObject_NotNullString() { |
| assertTrue(notNullObject != notNullString); |
| } |
| |
| public void test_NotNullObject_null() { |
| assertTrue(notNullObject != null); |
| } |
| |
| public void test_NotNullString_NotNullFoo() { |
| assertTrue(notNullString != notNullTightenFoo); |
| } |
| |
| public void test_NotNullString_NotNullObject() { |
| assertTrue(notNullString != notNullObject); |
| } |
| |
| @SuppressWarnings("SelfEquality") |
| public void test_NotNullString_NotNullString() { |
| assertTrue(notNullString == notNullString); |
| assertTrue(notNullString != notNullStringOther); |
| } |
| |
| public void test_NotNullString_null() { |
| assertTrue(notNullString != null); |
| } |
| public void test_null_MaybeNullFoo() { |
| assertTrue(null != maybeNullFoo); |
| assertTrue(null == maybeNullFooIsNull); |
| assertTrue(null == maybeNullFooIsUndefined); |
| } |
| |
| public void test_null_MaybeNullObject() { |
| assertTrue(null != maybeNullObject); |
| assertTrue(null == maybeNullObjectIsNull); |
| assertTrue(null == maybeNullObjectIsUndefined); |
| } |
| |
| public void test_null_MaybeNullString() { |
| assertTrue(null != maybeNullString); |
| assertTrue(null == maybeNullStringIsNull); |
| assertTrue(null == maybeNullStringIsUndefined); |
| } |
| |
| public void test_null_NotNullFoo() { |
| assertTrue(null != notNullFoo); |
| } |
| |
| public void test_null_NotNullObject() { |
| assertTrue(null != notNullObject); |
| } |
| |
| public void test_null_NotNullString() { |
| assertTrue(null != notNullString); |
| } |
| |
| public void test_null_null() { |
| assertTrue(null == null); |
| } |
| |
| private Foo undefinedFoo() { |
| return GWT.isClient() ? undefinedFoo0() : null; |
| } |
| |
| private Object undefinedObject() { |
| return GWT.isClient() ? undefinedObject0() : null; |
| } |
| |
| private String undefinedString() { |
| return GWT.isClient() ? undefinedString0() : null; |
| } |
| |
| private native Foo undefinedFoo0() /*-{ |
| }-*/; |
| |
| private native Object undefinedObject0() /*-{ |
| }-*/; |
| |
| private native String undefinedString0() /*-{ |
| }-*/; |
| } |