Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2007 The Guava Authors
   *
   * 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.common.collect.testing.testers;
 
 import static com.google.common.collect.testing.features.CollectionSize.ZERO;
 import static com.google.common.collect.testing.features.MapFeature.ALLOWS_NULL_KEYS;
 import static com.google.common.collect.testing.features.MapFeature.ALLOWS_NULL_VALUES;
 import static com.google.common.collect.testing.features.MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION;
 import static com.google.common.collect.testing.features.MapFeature.SUPPORTS_PUT;
 import static java.util.Collections.singletonList;
 
 
 import java.util.List;
 import java.util.Map;
A generic JUnit test which tests putAll operations on a map. Can't be invoked directly; please see com.google.common.collect.testing.MapTestSuiteBuilder.

Author(s):
Chris Povirk
Kevin Bourrillion
 
 @SuppressWarnings("unchecked"// too many "unchecked generic array creations"
 @GwtCompatible(emulated = true)
 public class MapPutAllTester<K, V> extends AbstractMapTester<K, V> {
   private List<Entry<K, V>> containsNullKey;
   private List<Entry<K, V>> containsNullValue;
 
   @Override public void setUp() throws Exception {
     super.setUp();
   }
 
   public void testPutAll_supportedNothing() {
     getMap().putAll(emptyMap());
     expectUnchanged();
   }
 
   @MapFeature.Require(absent = )
   public void testPutAll_unsupportedNothing() {
     try {
       getMap().putAll(emptyMap());
     } catch (UnsupportedOperationException tolerated) {
     }
     expectUnchanged();
   }
 
   public void testPutAll_supportedNonePresent() {
   }
 
   @MapFeature.Require(absent = )
   public void testPutAll_unsupportedNonePresent() {
     try {
       fail("putAll(nonePresent) should throw");
     } catch (UnsupportedOperationException expected) {
     }
     expectUnchanged();
   }
 
   @CollectionSize.Require(absent = )
   public void testPutAll_supportedSomePresent() {
     putAll(MinimalCollection.of(..));
  }
       })
  @CollectionSize.Require(absent = )
    try {
      Iterator<Entry<K, V>> iterator = getMap().entrySet().iterator();
      putAll(MinimalCollection.of(..));
      iterator.next();
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }
  @CollectionSize.Require(absent = )
    try {
      putAll(MinimalCollection.of(..));
      fail("putAll(somePresent) should throw");
    } catch (UnsupportedOperationException expected) {
    }
  }
  @CollectionSize.Require(absent = )
    try {
      putAll(MinimalCollection.of(.));
    } catch (UnsupportedOperationException tolerated) {
    }
  }
      })
  public void testPutAll_nullKeySupported() {
  }
      absent = )
  public void testPutAll_nullKeyUnsupported() {
    try {
      fail("putAll(containsNullKey) should throw");
    } catch (NullPointerException expected) {
    }
        "Should not contain null key after unsupported " +
        "putAll(containsNullKey)");
  }
      })
  public void testPutAll_nullValueSupported() {
  }
      absent = )
  public void testPutAll_nullValueUnsupported() {
    try {
      fail("putAll(containsNullValue) should throw");
    } catch (NullPointerException expected) {
    }
        "Should not contain null value after unsupported " +
        "putAll(containsNullValue)");
  }
    try {
      getMap().putAll(null);
      fail("putAll(null) should throw NullPointerException");
    } catch (NullPointerException expected) {
    }
  }
  private Map<K, V> emptyMap() {
    return Collections.emptyMap();
  }
  private void putAll(Iterable<Entry<K, V>> entries) {
    Map<K, V> map = new LinkedHashMap<K, V>();
    for (Entry<K, V> entry : entries) {
      map.put(entry.getKey(), entry.getValue());
    }
    getMap().putAll(map);
  }

  
Returns the java.lang.reflect.Method instance for testPutAll_nullKeyUnsupported() so that tests can suppress it with FeatureSpecificTestSuiteBuilder.suppressing() until Sun bug 5045147 is fixed.
  @GwtIncompatible("reflection")
    return Helpers.getMethod(MapPutAllTester.class"testPutAll_nullKeyUnsupported");
  }
New to GrepCode? Check out our FAQ X