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 java.util.Arrays.asList;
 
 
 import java.util.List;

Common generators of different types of lists.

Author(s):
Hayward Chan
 
 public final class ListGenerators {
 
   private ListGenerators() {}
 
   public static class ImmutableListOfGenerator extends TestStringListGenerator {
     @Override protected List<Stringcreate(String[] elements) {
       return ImmutableList.copyOf(elements);
     }
   }
 
   public static class BuilderAddListGenerator extends TestStringListGenerator {
     @Override protected List<Stringcreate(String[] elements) {
       ImmutableList.Builder<Stringbuilder = ImmutableList.<String>builder();
       for (String element : elements) {
         builder.add(element);
       }
       return builder.build();
     }
   }
 
   public static class BuilderAddAllListGenerator
       extends TestStringListGenerator {
     @Override protected List<Stringcreate(String[] elements) {
       return ImmutableList.<String>builder()
           .addAll(asList(elements))
           .build();
     }
   }
 
   public static class BuilderReversedListGenerator
       extends TestStringListGenerator {
     @Override protected List<Stringcreate(String[] elements) {
       List<Stringlist = asList(elements);
       Collections.reverse(list);
       return ImmutableList.copyOf(list).reverse();
     }
   }
 
   public static class ImmutableListHeadSubListGenerator
       extends TestStringListGenerator {
     @Override protected List<Stringcreate(String[] elements) {
       String[] suffix = {"f""g"};
       String[] all = new String[elements.length + suffix.length];
       System.arraycopy(elements, 0, all, 0, elements.length);
       System.arraycopy(suffix, 0, allelements.lengthsuffix.length);
       return ImmutableList.copyOf(all)
           .subList(0, elements.length);
     }
   }
 
   public static class ImmutableListTailSubListGenerator
       extends TestStringListGenerator {
     @Override protected List<Stringcreate(String[] elements) {
       String[] prefix = {"f""g"};
       String[] all = new String[elements.length + prefix.length];
       System.arraycopy(prefix, 0, all, 0, 2);
       System.arraycopy(elements, 0, all, 2, elements.length);
       return ImmutableList.copyOf(all)
           .subList(2, elements.length + 2);
    }
  }
  public static class ImmutableListMiddleSubListGenerator
      extends TestStringListGenerator {
    @Override protected List<Stringcreate(String[] elements) {
      String[] prefix = {"f""g"};
      String[] suffix = {"h""i"};
      String[] all = new String[2 + elements.length + 2];
      System.arraycopy(prefix, 0, all, 0, 2);
      System.arraycopy(elements, 0, all, 2, elements.length);
      System.arraycopy(suffix, 0, all, 2 + elements.length, 2);
      return ImmutableList.copyOf(all)
          .subList(2, elements.length + 2);
    }
  }
  public static class CharactersOfStringGenerator
      extends TestCharacterListGenerator {
    @Override public List<Charactercreate(Character[] elements) {
      char[] chars = Chars.toArray(Arrays.asList(elements));
      return Lists.charactersOf(String.copyValueOf(chars));
    }
  }
  public static class CharactersOfCharSequenceGenerator
      extends TestCharacterListGenerator {
    @Override public List<Charactercreate(Character[] elements) {
      char[] chars = Chars.toArray(Arrays.asList(elements));
      StringBuilder str = new StringBuilder();
      str.append(chars);
      return Lists.charactersOf(str);
    }
  }
  private abstract static class TestUnhashableListGenerator
      implements TestListGenerator<UnhashableObject> {
  }
      extends TestUnhashableListGenerator {
    @Override
    public List<UnhashableObjectcreate(UnhashableObject[] elements) {
      return ImmutableList.copyOf(elements);
    }
  }
New to GrepCode? Check out our FAQ X