001/*
002 *  jDTAUS Core RI Client Container
003 *  Copyright (C) 2005 Christian Schulte
004 *  <cs@schulte.it>
005 *
006 *  This library is free software; you can redistribute it and/or
007 *  modify it under the terms of the GNU Lesser General Public
008 *  License as published by the Free Software Foundation; either
009 *  version 2.1 of the License, or any later version.
010 *
011 *  This library is distributed in the hope that it will be useful,
012 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
013 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014 *  Lesser General Public License for more details.
015 *
016 *  You should have received a copy of the GNU Lesser General Public
017 *  License along with this library; if not, write to the Free Software
018 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
019 *
020 */
021package org.jdtaus.core.container.ri.client.test;
022
023import java.util.ConcurrentModificationException;
024import java.util.Iterator;
025import java.util.Map;
026import junit.framework.Assert;
027import junit.framework.TestCase;
028import org.jdtaus.core.container.ri.client.WeakIdentityHashMap;
029
030/**
031 * Tests the {@code WeakIdentityHashMap} implementation.
032 *
033 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
034 * @version $JDTAUS: WeakIdentityHashMapTest.java 8641 2012-09-27 06:45:17Z schulte $
035 */
036public class WeakIdentityHashMapTest extends TestCase
037{
038    //--Tests-------------------------------------------------------------------
039
040    public void testObject() throws Exception
041    {
042        final Map m1 = new WeakIdentityHashMap();
043        final Map m2 = new WeakIdentityHashMap();
044
045        Assert.assertEquals( m1, m2 );
046        Assert.assertEquals( m1.hashCode(), m2.hashCode() );
047
048        Assert.assertEquals( m1.entrySet(), m2.entrySet() );
049        Assert.assertEquals( m1.entrySet().hashCode(),
050            m2.entrySet().hashCode() );
051
052        Assert.assertEquals( m1.keySet(), m2.keySet() );
053        Assert.assertEquals( m1.keySet().hashCode(), m2.keySet().hashCode() );
054
055        System.out.println( m1 );
056        System.out.println( m1.keySet() );
057        System.out.println( m1.entrySet() );
058        System.out.println( m1.values() );
059
060        System.out.println( m2 );
061        System.out.println( m2.keySet() );
062        System.out.println( m2.entrySet() );
063        System.out.println( m2.values() );
064
065        final Object o = new Object(); // Must not get garbage collected.
066        m1.put( o, "TEST" );
067
068        Assert.assertFalse( m1.equals( m2 ) );
069        Assert.assertFalse( m1.hashCode() == m2.hashCode() );
070    }
071
072    public void testPutGetRemove() throws Exception
073    {
074        final Object o1 = new Object(); // Must not get garbage collected.
075        final Object o2 = new Object(); // Must not get garbage collected.
076        final Map m1 = new WeakIdentityHashMap();
077
078        Assert.assertTrue( m1.isEmpty() );
079        Assert.assertEquals( m1.size(), 0 );
080        Assert.assertFalse( m1.containsKey( o1 ) );
081        Assert.assertFalse( m1.containsKey( o2 ) );
082        Assert.assertFalse( m1.containsValue( "TEST1" ) );
083        Assert.assertFalse( m1.containsValue( "TEST2" ) );
084
085        System.out.println( m1 );
086
087        m1.put( o1, "TEST1" );
088        m1.put( o2, "TEST2" );
089
090        Assert.assertFalse( m1.isEmpty() );
091        Assert.assertEquals( 2, m1.size() );
092        Assert.assertTrue( m1.containsKey( o1 ) );
093        Assert.assertTrue( m1.containsKey( o2 ) );
094        Assert.assertTrue( m1.containsValue( "TEST1" ) );
095        Assert.assertTrue( m1.containsValue( "TEST2" ) );
096
097        System.out.println( m1 );
098
099        m1.clear();
100
101        Assert.assertTrue( m1.isEmpty() );
102        Assert.assertEquals( m1.size(), 0 );
103        Assert.assertFalse( m1.containsKey( o1 ) );
104        Assert.assertFalse( m1.containsKey( o2 ) );
105        Assert.assertFalse( m1.containsValue( "TEST1" ) );
106        Assert.assertFalse( m1.containsValue( "TEST2" ) );
107
108        System.out.println( m1 );
109    }
110
111    public void testConcurrentModificationException() throws Exception
112    {
113        final Object o1 = new Object(); // Must not get garbage collected.
114        final Object o2 = new Object(); // Must not get garbage collected.
115        final Map m1 = new WeakIdentityHashMap();
116
117        m1.put( o1, "TEST1" );
118        m1.put( o2, "TEST2" );
119
120        final Iterator keyIterator = m1.keySet().iterator();
121        final Iterator valueIterator = m1.values().iterator();
122        final Iterator entryIterator = m1.entrySet().iterator();
123
124        m1.clear();
125
126        try
127        {
128            keyIterator.hasNext();
129            throw new AssertionError();
130        }
131        catch ( ConcurrentModificationException e )
132        {
133            Assert.assertNotNull( e.getMessage() );
134            System.out.println( e.toString() );
135        }
136
137        try
138        {
139            valueIterator.hasNext();
140            throw new AssertionError();
141        }
142        catch ( ConcurrentModificationException e )
143        {
144            Assert.assertNotNull( e.getMessage() );
145            System.out.println( e.toString() );
146        }
147
148        try
149        {
150            entryIterator.hasNext();
151            throw new AssertionError();
152        }
153        catch ( ConcurrentModificationException e )
154        {
155            Assert.assertNotNull( e.getMessage() );
156            System.out.println( e.toString() );
157        }
158    }
159
160    public void testRemoveThroughIterator() throws Exception
161    {
162        final Object o1 = new Object(); // Must not get garbage collected.
163        final Object o2 = new Object(); // Must not get garbage collected.
164        final Map m1 = new WeakIdentityHashMap();
165
166        m1.put( o1, "TEST1" );
167        m1.put( o2, "TEST2" );
168
169        Assert.assertFalse( m1.isEmpty() );
170        Assert.assertEquals( m1.size(), 2 );
171        Assert.assertTrue( m1.containsKey( o1 ) );
172        Assert.assertTrue( m1.containsKey( o2 ) );
173        Assert.assertTrue( m1.containsValue( "TEST1" ) );
174        Assert.assertTrue( m1.containsValue( "TEST2" ) );
175
176        final Iterator keyIterator = m1.keySet().iterator();
177        keyIterator.next();
178        keyIterator.remove();
179        keyIterator.next();
180        keyIterator.remove();
181
182        Assert.assertFalse( keyIterator.hasNext() );
183        Assert.assertTrue( m1.isEmpty() );
184        Assert.assertEquals( m1.size(), 0 );
185        Assert.assertFalse( m1.containsKey( o1 ) );
186        Assert.assertFalse( m1.containsKey( o2 ) );
187        Assert.assertFalse( m1.containsValue( "TEST1" ) );
188        Assert.assertFalse( m1.containsValue( "TEST2" ) );
189
190        m1.put( o1, "TEST1" );
191        m1.put( o2, "TEST2" );
192
193        final Iterator valueIterator = m1.keySet().iterator();
194        valueIterator.next();
195        valueIterator.remove();
196        valueIterator.next();
197        valueIterator.remove();
198
199        Assert.assertFalse( valueIterator.hasNext() );
200        Assert.assertTrue( m1.isEmpty() );
201        Assert.assertEquals( m1.size(), 0 );
202        Assert.assertFalse( m1.containsKey( o1 ) );
203        Assert.assertFalse( m1.containsKey( o2 ) );
204        Assert.assertFalse( m1.containsValue( "TEST1" ) );
205        Assert.assertFalse( m1.containsValue( "TEST2" ) );
206
207        m1.put( o1, "TEST1" );
208        m1.put( o2, "TEST2" );
209
210        final Iterator entryIterator = m1.keySet().iterator();
211        entryIterator.next();
212        entryIterator.remove();
213        entryIterator.next();
214        entryIterator.remove();
215
216        Assert.assertFalse( entryIterator.hasNext() );
217        Assert.assertTrue( m1.isEmpty() );
218        Assert.assertEquals( m1.size(), 0 );
219        Assert.assertFalse( m1.containsKey( o1 ) );
220        Assert.assertFalse( m1.containsKey( o2 ) );
221        Assert.assertFalse( m1.containsValue( "TEST1" ) );
222        Assert.assertFalse( m1.containsValue( "TEST2" ) );
223    }
224
225    //-------------------------------------------------------------------Tests--
226}