Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2009 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.google;
 
 import static com.google.common.collect.testing.Helpers.mapEntry;
 
 
 import java.util.List;
 import java.util.Map;
Generators of different types of map and related collections, such as keys, entries and values.

Author(s):
Hayward Chan
 
 public class MapGenerators {
   public static class ImmutableMapGenerator
       extends TestStringMapGenerator {
     @Override protected Map<StringStringcreate(Entry<StringString>[] entries) {
       ImmutableMap.Builder<StringStringbuilder = ImmutableMap.builder();
       for (Entry<StringStringentry : entries) {
         builder.put(entry.getKey(), entry.getValue());
       }
       return builder.build();
     }
   }
   
   public static class ImmutableMapCopyOfGenerator
       extends TestStringMapGenerator {
     @Override protected Map<StringStringcreate(Entry<StringString>[] entries) {
       Map<StringStringbuilder = Maps.newLinkedHashMap();
       for (Entry<StringStringentry : entries) {
         builder.put(entry.getKey(), entry.getValue());
       }
       return ImmutableMap.copyOf(builder);
     }
   }
 
   public static class ImmutableMapUnhashableValuesGenerator
 
         UnhashableObject[] elements) {
       ImmutableMap.Builder<IntegerUnhashableObjectbuilder = ImmutableMap.builder();
       int key = 1;
       for (UnhashableObject value : elements) {
         builder.put(key++, value);
       }
       return builder.build().values();
     }
   }
 
   public static class ImmutableMapKeyListGenerator extends TestStringListGenerator {
     @Override
     public List<Stringcreate(String[] elements) {
       ImmutableMap.Builder<StringIntegerbuilder = ImmutableMap.builder();
       for (int i = 0; i < elements.lengthi++) {
         builder.put(elements[i], i);
       }
       return builder.build().keySet().asList();
     }
   }
 
   public static class ImmutableMapValueListGenerator extends TestStringListGenerator {
     @Override
     public List<Stringcreate(String[] elements) {
       ImmutableMap.Builder<IntegerStringbuilder = ImmutableMap.builder();
       for (int i = 0; i < elements.lengthi++) {
        builder.put(ielements[i]);
      }
      return builder.build().values().asList();
    }
  }
  public static class ImmutableMapEntryListGenerator
      implements TestListGenerator<Entry<StringInteger>> {
    @Override
    public SampleElements<Entry<StringInteger>> samples() {
      return new SampleElements<Entry<StringInteger>>(
          mapEntry("foo", 5),
          mapEntry("bar", 3),
          mapEntry("baz", 17),
          mapEntry("quux", 1),
          mapEntry("toaster", -2));
    }
    @SuppressWarnings("unchecked")
    @Override
    public Entry<StringInteger>[] createArray(int length) {
      return new Entry[length];
    }
    @Override
    public Iterable<Entry<StringInteger>> order(List<Entry<StringInteger>> insertionOrder) {
      return insertionOrder;
    }
    @Override
    public List<Entry<StringInteger>> create(Object... elements) {
      ImmutableMap.Builder<StringIntegerbuilder = ImmutableMap.builder();
      for (Object o : elements) {
        @SuppressWarnings("unchecked")
        Entry<StringIntegerentry = (Entry<StringInteger>) o;
        builder.put(entry);
      }
      return builder.build().entrySet().asList();
    }
  }
  public static class ImmutableEnumMapGenerator extends TestEnumMapGenerator {
    @Override
    protected Map<AnEnumStringcreate(Entry<AnEnumString>[] entries) {
      Map<AnEnumStringmap = Maps.newHashMap();
      for (Entry<AnEnumStringentry : entries) {
        // checkArgument(!map.containsKey(entry.getKey()));
        map.put(entry.getKey(), entry.getValue());
      }
      return Maps.immutableEnumMap(map);
    }
  }
  public static class ImmutableMapCopyOfEnumMapGenerator extends TestEnumMapGenerator {
    @Override
    protected Map<AnEnumStringcreate(Entry<AnEnumString>[] entries) {
      EnumMap<AnEnumStringmap = new EnumMap<AnEnumString>(AnEnum.class);
      for (Entry<AnEnumStringentry : entries) {
        map.put(entry.getKey(), entry.getValue());
      }
      return ImmutableMap.copyOf(map);
    }
    @Override
    public Iterable<Entry<AnEnumString>> order(List<Entry<AnEnumString>> insertionOrder) {
      return new Ordering<Entry<AnEnumString>>() {
        @Override
        public int compare(Entry<AnEnumStringleftEntry<AnEnumStringright) {
          return left.getKey().compareTo(right.getKey());
        }
      }.sortedCopy(insertionOrder);
    }
  }
  private static String toStringOrNull(Object o) {
    return (o == null) ? null : o.toString();
  }
New to GrepCode? Check out our FAQ X