TestMu Conference is Back! Future of Testing + AI LambdaTest G2 Announcement

How to use size method of org.assertj.core.test.jdk11.ImmutableCollections class

Best Assertj code snippet using org.assertj.core.test.jdk11.ImmutableCollections.size

Source:Jdk11.java

...233     * See <a href="#unmodifiable">Unmodifiable Sets</a> for details.234     *235     * @apiNote236     * This method also accepts a single array as an argument. The element type of237     * the resulting set will be the component type of the array, and the size of238     * the set will be equal to the length of the array. To create a set with239     * a single element that is an array, do the following:240     *241     * <pre>{@code242     *     String[] array = ... ;243     *     Set<String[]> list = Set.<String[]>of(array);244     * }</pre>245     *246     * This will cause the {@link java.util.Set#of(Object) Set.of(E)} method247     * to be invoked instead.248     *249     * @param <E> the {@code Set}'s element type250     * @param elements the elements to be contained in the set251     * @return a {@code Set} containing the specified elements252     * @throws IllegalArgumentException if there are any duplicate elements253     * @throws NullPointerException if an element is {@code null} or if the array is {@code null}254     *255     * @since 9256     */257    @SafeVarargs258    @SuppressWarnings("varargs")259    static <E> java.util.Set<E> of(E... elements) {260      switch (elements.length) { // implicit null check of elements261      case 0:262        return ImmutableCollections.emptySet();263      case 1:264        return new ImmutableCollections.Set12<>(elements[0]);265      case 2:266        return new ImmutableCollections.Set12<>(elements[0], elements[1]);267      default:268        return new ImmutableCollections.SetN<>(elements);269      }270    }271    /**272     * Returns an <a href="#unmodifiable">unmodifiable Set</a> containing the elements273     * of the given Collection. The given Collection must not be null, and it must not274     * contain any null elements. If the given Collection contains duplicate elements,275     * an arbitrary element of the duplicates is preserved. If the given Collection is276     * subsequently modified, the returned Set will not reflect such modifications.277     *278     * @implNote279     * If the given Collection is an <a href="#unmodifiable">unmodifiable Set</a>,280     * calling copyOf will generally not create a copy.281     *282     * @param <E> the {@code Set}'s element type283     * @param coll a {@code Collection} from which elements are drawn, must be non-null284     * @return a {@code Set} containing the elements of the given {@code Collection}285     * @throws NullPointerException if coll is null, or if it contains any nulls286     * @since 10287     */288    @SuppressWarnings("unchecked")289    static <E> java.util.Set<E> copyOf(Collection<? extends E> coll) {290      if (coll instanceof ImmutableCollections.AbstractImmutableSet) {291        return (java.util.Set<E>) coll;292      } else {293        return (java.util.Set<E>) Set.of(new HashSet<>(coll).toArray());294      }295    }296  }297  public interface List {298    /**299     * Returns an unmodifiable list containing zero elements.300     *301     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.302     *303     * @param <E> the {@code List}'s element type304     * @return an empty {@code List}305     *306     * @since 9307     */308    static <E> java.util.List<E> of() {309      return ImmutableCollections.emptyList();310    }311    /**312     * Returns an unmodifiable list containing one element.313     *314     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.315     *316     * @param <E> the {@code List}'s element type317     * @param e1 the single element318     * @return a {@code List} containing the specified element319     * @throws NullPointerException if the element is {@code null}320     *321     * @since 9322     */323    static <E> java.util.List<E> of(E e1) {324      return new ImmutableCollections.List12<>(e1);325    }326    /**327     * Returns an unmodifiable list containing two elements.328     *329     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.330     *331     * @param <E> the {@code List}'s element type332     * @param e1 the first element333     * @param e2 the second element334     * @return a {@code List} containing the specified elements335     * @throws NullPointerException if an element is {@code null}336     *337     * @since 9338     */339    static <E> java.util.List<E> of(E e1, E e2) {340      return new ImmutableCollections.List12<>(e1, e2);341    }342    /**343     * Returns an unmodifiable list containing three elements.344     *345     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.346     *347     * @param <E> the {@code List}'s element type348     * @param e1 the first element349     * @param e2 the second element350     * @param e3 the third element351     * @return a {@code List} containing the specified elements352     * @throws NullPointerException if an element is {@code null}353     *354     * @since 9355     */356    static <E> java.util.List<E> of(E e1, E e2, E e3) {357      return new ImmutableCollections.ListN<>(e1, e2, e3);358    }359    /**360     * Returns an unmodifiable list containing four elements.361     *362     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.363     *364     * @param <E> the {@code List}'s element type365     * @param e1 the first element366     * @param e2 the second element367     * @param e3 the third element368     * @param e4 the fourth element369     * @return a {@code List} containing the specified elements370     * @throws NullPointerException if an element is {@code null}371     *372     * @since 9373     */374    static <E> java.util.List<E> of(E e1, E e2, E e3, E e4) {375      return new ImmutableCollections.ListN<>(e1, e2, e3, e4);376    }377    /**378     * Returns an unmodifiable list containing five elements.379     *380     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.381     *382     * @param <E> the {@code List}'s element type383     * @param e1 the first element384     * @param e2 the second element385     * @param e3 the third element386     * @param e4 the fourth element387     * @param e5 the fifth element388     * @return a {@code List} containing the specified elements389     * @throws NullPointerException if an element is {@code null}390     *391     * @since 9392     */393    static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5) {394      return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);395    }396    /**397     * Returns an unmodifiable list containing six elements.398     *399     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.400     *401     * @param <E> the {@code List}'s element type402     * @param e1 the first element403     * @param e2 the second element404     * @param e3 the third element405     * @param e4 the fourth element406     * @param e5 the fifth element407     * @param e6 the sixth element408     * @return a {@code List} containing the specified elements409     * @throws NullPointerException if an element is {@code null}410     *411     * @since 9412     */413    static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {414      return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,415                                              e6);416    }417    /**418     * Returns an unmodifiable list containing seven elements.419     *420     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.421     *422     * @param <E> the {@code List}'s element type423     * @param e1 the first element424     * @param e2 the second element425     * @param e3 the third element426     * @param e4 the fourth element427     * @param e5 the fifth element428     * @param e6 the sixth element429     * @param e7 the seventh element430     * @return a {@code List} containing the specified elements431     * @throws NullPointerException if an element is {@code null}432     *433     * @since 9434     */435    static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {436      return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,437                                              e6, e7);438    }439    /**440     * Returns an unmodifiable list containing eight elements.441     *442     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.443     *444     * @param <E> the {@code List}'s element type445     * @param e1 the first element446     * @param e2 the second element447     * @param e3 the third element448     * @param e4 the fourth element449     * @param e5 the fifth element450     * @param e6 the sixth element451     * @param e7 the seventh element452     * @param e8 the eighth element453     * @return a {@code List} containing the specified elements454     * @throws NullPointerException if an element is {@code null}455     *456     * @since 9457     */458    static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {459      return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,460                                              e6, e7, e8);461    }462    /**463     * Returns an unmodifiable list containing nine elements.464     *465     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.466     *467     * @param <E> the {@code List}'s element type468     * @param e1 the first element469     * @param e2 the second element470     * @param e3 the third element471     * @param e4 the fourth element472     * @param e5 the fifth element473     * @param e6 the sixth element474     * @param e7 the seventh element475     * @param e8 the eighth element476     * @param e9 the ninth element477     * @return a {@code List} containing the specified elements478     * @throws NullPointerException if an element is {@code null}479     *480     * @since 9481     */482    static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {483      return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,484                                              e6, e7, e8, e9);485    }486    /**487     * Returns an unmodifiable list containing ten elements.488     *489     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.490     *491     * @param <E> the {@code List}'s element type492     * @param e1 the first element493     * @param e2 the second element494     * @param e3 the third element495     * @param e4 the fourth element496     * @param e5 the fifth element497     * @param e6 the sixth element498     * @param e7 the seventh element499     * @param e8 the eighth element500     * @param e9 the ninth element501     * @param e10 the tenth element502     * @return a {@code List} containing the specified elements503     * @throws NullPointerException if an element is {@code null}504     *505     * @since 9506     */507    static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {508      return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,509                                              e6, e7, e8, e9, e10);510    }511    /**512     * Returns an unmodifiable list containing an arbitrary number of elements.513     * See <a href="#unmodifiable">Unmodifiable Lists</a> for details.514     *515     * @apiNote516     * This method also accepts a single array as an argument. The element type of517     * the resulting list will be the component type of the array, and the size of518     * the list will be equal to the length of the array. To create a list with519     * a single element that is an array, do the following:520     *521     * <pre>{@code522     *     String[] array = ... ;523     *     List<String[]> list = List.<String[]>of(array);524     * }</pre>525     *526     * This will cause the {@link java.util.List#of(Object) List.of(E)} method527     * to be invoked instead.528     *529     * @param <E> the {@code List}'s element type530     * @param elements the elements to be contained in the list531     * @return a {@code List} containing the specified elements...

Source:ImmutableCollections.java

...58  /** No instances. */59  private ImmutableCollections() {}60  /**61   * The reciprocal of load factor. Given a number of elements62   * to store, multiply by this factor to get the table size.63   */64  static final int EXPAND_FACTOR = 2;65  static UnsupportedOperationException uoe() {66    return new UnsupportedOperationException();67  }68  static abstract class AbstractImmutableCollection<E> extends AbstractCollection<E> {69    // all mutating methods throw UnsupportedOperationException70    @Override71    public boolean add(E e) {72      throw uoe();73    }74    @Override75    public boolean addAll(Collection<? extends E> c) {76      throw uoe();77    }78    @Override79    public void clear() {80      throw uoe();81    }82    @Override83    public boolean remove(Object o) {84      throw uoe();85    }86    @Override87    public boolean removeAll(Collection<?> c) {88      throw uoe();89    }90    @Override91    public boolean removeIf(Predicate<? super E> filter) {92      throw uoe();93    }94    @Override95    public boolean retainAll(Collection<?> c) {96      throw uoe();97    }98  }99  // ---------- List Implementations ----------100  // make a copy, short-circuiting based on implementation class101  @SuppressWarnings("unchecked")102  static <E> List<E> listCopy(Collection<? extends E> coll) {103    if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {104      return (List<E>) coll;105    } else {106      return (List<E>) Jdk11.List.of(coll.toArray());107    }108  }109  @SuppressWarnings("unchecked")110  static <E> List<E> emptyList() {111    return (List<E>) ListN.EMPTY_LIST;112  }113  static abstract class AbstractImmutableList<E> extends AbstractImmutableCollection<E>114      implements List<E>, RandomAccess {115    // all mutating methods throw UnsupportedOperationException116    @Override117    public void add(int index, E element) {118      throw uoe();119    }120    @Override121    public boolean addAll(int index, Collection<? extends E> c) {122      throw uoe();123    }124    @Override125    public E remove(int index) {126      throw uoe();127    }128    @Override129    public void replaceAll(UnaryOperator<E> operator) {130      throw uoe();131    }132    @Override133    public E set(int index, E element) {134      throw uoe();135    }136    @Override137    public void sort(Comparator<? super E> c) {138      throw uoe();139    }140    @Override141    public List<E> subList(int fromIndex, int toIndex) {142      int size = size();143      subListRangeCheck(fromIndex, toIndex, size);144      return SubList.fromList(this, fromIndex, toIndex);145    }146    static void subListRangeCheck(int fromIndex, int toIndex, int size) {147      if (fromIndex < 0)148        throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);149      if (toIndex > size)150        throw new IndexOutOfBoundsException("toIndex = " + toIndex);151      if (fromIndex > toIndex)152        throw new IllegalArgumentException("fromIndex(" + fromIndex +153                                           ") > toIndex(" + toIndex + ")");154    }155    @Override156    public Iterator<E> iterator() {157      return new ListItr<E>(this, size());158    }159    @Override160    public ListIterator<E> listIterator() {161      return listIterator(0);162    }163    @Override164    public ListIterator<E> listIterator(final int index) {165      int size = size();166      if (index < 0 || index > size) {167        throw outOfBounds(index);168      }169      return new ListItr<E>(this, size, index);170    }171    @Override172    public boolean equals(Object o) {173      if (o == this) {174        return true;175      }176      if (!(o instanceof List)) {177        return false;178      }179      Iterator<?> oit = ((List<?>) o).iterator();180      for (int i = 0, s = size(); i < s; i++) {181        if (!oit.hasNext() || !get(i).equals(oit.next())) {182          return false;183        }184      }185      return !oit.hasNext();186    }187    @Override188    public int indexOf(Object o) {189      Objects.requireNonNull(o);190      for (int i = 0, s = size(); i < s; i++) {191        if (o.equals(get(i))) {192          return i;193        }194      }195      return -1;196    }197    @Override198    public int lastIndexOf(Object o) {199      Objects.requireNonNull(o);200      for (int i = size() - 1; i >= 0; i--) {201        if (o.equals(get(i))) {202          return i;203        }204      }205      return -1;206    }207    @Override208    public int hashCode() {209      int hash = 1;210      for (int i = 0, s = size(); i < s; i++) {211        hash = 31 * hash + get(i).hashCode();212      }213      return hash;214    }215    @Override216    public boolean contains(Object o) {217      return indexOf(o) >= 0;218    }219    IndexOutOfBoundsException outOfBounds(int index) {220      return new IndexOutOfBoundsException("Index: " + index + " Size: " + size());221    }222  }223  static final class ListItr<E> implements ListIterator<E> {224    private final List<E> list;225    private final int size;226    private final boolean isListIterator;227    private int cursor;228    ListItr(List<E> list, int size) {229      this.list = list;230      this.size = size;231      this.cursor = 0;232      isListIterator = false;233    }234    ListItr(List<E> list, int size, int index) {235      this.list = list;236      this.size = size;237      this.cursor = index;238      isListIterator = true;239    }240    public boolean hasNext() {241      return cursor != size;242    }243    public E next() {244      try {245        int i = cursor;246        E next = list.get(i);247        cursor = i + 1;248        return next;249      } catch (IndexOutOfBoundsException e) {250        throw new NoSuchElementException();251      }252    }253    public void remove() {254      throw uoe();255    }256    public boolean hasPrevious() {257      if (!isListIterator) {258        throw uoe();259      }260      return cursor != 0;261    }262    public E previous() {263      if (!isListIterator) {264        throw uoe();265      }266      try {267        int i = cursor - 1;268        E previous = list.get(i);269        cursor = i;270        return previous;271      } catch (IndexOutOfBoundsException e) {272        throw new NoSuchElementException();273      }274    }275    public int nextIndex() {276      if (!isListIterator) {277        throw uoe();278      }279      return cursor;280    }281    public int previousIndex() {282      if (!isListIterator) {283        throw uoe();284      }285      return cursor - 1;286    }287    public void set(E e) {288      throw uoe();289    }290    public void add(E e) {291      throw uoe();292    }293  }294  static final class SubList<E> extends AbstractImmutableList<E>295      implements RandomAccess {296    private final List<E> root;297    private final int offset;298    private final int size;299    private SubList(List<E> root, int offset, int size) {300      this.root = root;301      this.offset = offset;302      this.size = size;303    }304    /**305     * Constructs a sublist of another SubList.306     */307    static <E> SubList<E> fromSubList(SubList<E> parent, int fromIndex, int toIndex) {308      return new SubList<>(parent.root, parent.offset + fromIndex, toIndex - fromIndex);309    }310    /**311     * Constructs a sublist of an arbitrary AbstractImmutableList, which is312     * not a SubList itself.313     */314    static <E> SubList<E> fromList(List<E> list, int fromIndex, int toIndex) {315      return new SubList<>(list, fromIndex, toIndex - fromIndex);316    }317    public E get(int index) {318      // Replacement for Objects.checkIndex(index, size);319      if (index < 0 || index >= size) {320        throw new IndexOutOfBoundsException(String.format("Index %s out of bounds for length %s", index, size));321      }322      return root.get(offset + index);323    }324    public int size() {325      return size;326    }327    public Iterator<E> iterator() {328      return new ListItr<>(this, size());329    }330    public ListIterator<E> listIterator(int index) {331      rangeCheck(index);332      return new ListItr<>(this, size(), index);333    }334    public List<E> subList(int fromIndex, int toIndex) {335      subListRangeCheck(fromIndex, toIndex, size);336      return SubList.fromSubList(this, fromIndex, toIndex);337    }338    private void rangeCheck(int index) {339      if (index < 0 || index > size) {340        throw outOfBounds(index);341      }342    }343  }344  static final class List12<E> extends AbstractImmutableList<E>345      implements Serializable {346    private final E e0;347    private final E e1;348    List12(E e0) {349      this.e0 = Objects.requireNonNull(e0);350      this.e1 = null;351    }352    List12(E e0, E e1) {353      this.e0 = Objects.requireNonNull(e0);354      this.e1 = Objects.requireNonNull(e1);355    }356    @Override357    public int size() {358      return e1 != null ? 2 : 1;359    }360    @Override361    public E get(int index) {362      if (index == 0) {363        return e0;364      } else if (index == 1 && e1 != null) {365        return e1;366      }367      throw outOfBounds(index);368    }369    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {370      throw new InvalidObjectException("not serial proxy");371    }372    private Object writeReplace() {373      if (e1 == null) {374        return new CollSer(CollSer.IMM_LIST, e0);375      } else {376        return new CollSer(CollSer.IMM_LIST, e0, e1);377      }378    }379  }380  static final class ListN<E> extends AbstractImmutableList<E>381      implements Serializable {382    // EMPTY_LIST may be initialized from the CDS archive.383    static List<?> EMPTY_LIST;384    static {385      // VM.initializeFromArchive(ListN.class);386      if (EMPTY_LIST == null) {387        EMPTY_LIST = new ListN<>();388      }389    }390    private final E[] elements;391    @SafeVarargs392    ListN(E... input) {393      // copy and check manually to avoid TOCTOU394      @SuppressWarnings("unchecked")395      E[] tmp = (E[]) new Object[input.length]; // implicit nullcheck of input396      for (int i = 0; i < input.length; i++) {397        tmp[i] = Objects.requireNonNull(input[i]);398      }399      elements = tmp;400    }401    @Override402    public boolean isEmpty() {403      return size() == 0;404    }405    @Override406    public int size() {407      return elements.length;408    }409    @Override410    public E get(int index) {411      return elements[index];412    }413    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {414      throw new InvalidObjectException("not serial proxy");415    }416    private Object writeReplace() {417      return new CollSer(CollSer.IMM_LIST, elements);418    }419  }420  // ---------- Set Implementations ----------421  static abstract class AbstractImmutableSet<E> extends AbstractImmutableCollection<E>422      implements Set<E> {423    @Override424    public boolean equals(Object o) {425      if (o == this) {426        return true;427      } else if (!(o instanceof Set)) {428        return false;429      }430      Collection<?> c = (Collection<?>) o;431      if (c.size() != size()) {432        return false;433      }434      for (Object e : c) {435        if (e == null || !contains(e)) {436          return false;437        }438      }439      return true;440    }441    @Override442    public abstract int hashCode();443  }444  @SuppressWarnings("unchecked")445  static <E> Set<E> emptySet() {446    return (Set<E>) SetN.EMPTY_SET;447  }448  static final class Set12<E> extends AbstractImmutableSet<E>449      implements Serializable {450    final E e0;451    final E e1;452    Set12(E e0) {453      this.e0 = Objects.requireNonNull(e0);454      this.e1 = null;455    }456    Set12(E e0, E e1) {457      if (e0.equals(Objects.requireNonNull(e1))) { // implicit nullcheck of e0458        throw new IllegalArgumentException("duplicate element: " + e0);459      }460      this.e0 = e0;461      this.e1 = e1;462    }463    @Override464    public int size() {465      return (e1 == null) ? 1 : 2;466    }467    @Override468    public boolean contains(Object o) {469      return o.equals(e0) || o.equals(e1); // implicit nullcheck of o470    }471    @Override472    public int hashCode() {473      return e0.hashCode() + (e1 == null ? 0 : e1.hashCode());474    }475    @Override476    public Iterator<E> iterator() {477      return new Iterator<E>() {478        private int idx = size();479        @Override480        public boolean hasNext() {481          return idx > 0;482        }483        @Override484        public E next() {485          if (idx == 1) {486            idx = 0;487            return SALT >= 0 || e1 == null ? e0 : e1;488          } else if (idx == 2) {489            idx = 1;490            return SALT >= 0 ? e1 : e0;491          } else {492            throw new NoSuchElementException();493          }494        }495      };496    }497    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {498      throw new InvalidObjectException("not serial proxy");499    }500    private Object writeReplace() {501      if (e1 == null) {502        return new CollSer(CollSer.IMM_SET, e0);503      } else {504        return new CollSer(CollSer.IMM_SET, e0, e1);505      }506    }507  }508  /**509   * An array-based Set implementation. The element array must be strictly510   * larger than the size (the number of contained elements) so that at511   * least one null is always present.512   * @param <E> the element type513   */514  static final class SetN<E> extends AbstractImmutableSet<E>515      implements Serializable {516    // EMPTY_SET may be initialized from the CDS archive.517    static Set<?> EMPTY_SET;518    static {519      // VM.initializeFromArchive(SetN.class);520      if (EMPTY_SET == null) {521        EMPTY_SET = new SetN<>();522      }523    }524    final E[] elements;525    final int size;526    @SafeVarargs527    @SuppressWarnings("unchecked")528    SetN(E... input) {529      size = input.length; // implicit nullcheck of input530      elements = (E[]) new Object[EXPAND_FACTOR * input.length];531      for (int i = 0; i < input.length; i++) {532        E e = input[i];533        int idx = probe(e); // implicit nullcheck of e534        if (idx >= 0) {535          throw new IllegalArgumentException("duplicate element: " + e);536        } else {537          elements[-(idx + 1)] = e;538        }539      }540    }541    @Override542    public int size() {543      return size;544    }545    @Override546    public boolean contains(Object o) {547      Objects.requireNonNull(o);548      return size > 0 && probe(o) >= 0;549    }550    private final class SetNIterator implements Iterator<E> {551      private int remaining;552      private int idx;553      SetNIterator() {554        remaining = size();555        if (remaining > 0) {556          idx = Math.floorMod(SALT, elements.length);557        }558      }559      @Override560      public boolean hasNext() {561        return remaining > 0;562      }563      private int nextIndex() {564        int idx = this.idx;565        if (SALT >= 0) {566          if (++idx >= elements.length) {567            idx = 0;568          }569        } else {570          if (--idx < 0) {571            idx = elements.length - 1;572          }573        }574        return this.idx = idx;575      }576      @Override577      public E next() {578        if (hasNext()) {579          E element;580          // skip null elements581          while ((element = elements[nextIndex()]) == null) {}582          remaining--;583          return element;584        } else {585          throw new NoSuchElementException();586        }587      }588    }589    @Override590    public Iterator<E> iterator() {591      return new SetN<E>.SetNIterator();592    }593    @Override594    public int hashCode() {595      int h = 0;596      for (E e : elements) {597        if (e != null) {598          h += e.hashCode();599        }600      }601      return h;602    }603    // returns index at which element is present; or if absent,604    // (-i - 1) where i is location where element should be inserted.605    // Callers are relying on this method to perform an implicit nullcheck606    // of pe607    private int probe(Object pe) {608      int idx = Math.floorMod(pe.hashCode(), elements.length);609      while (true) {610        E ee = elements[idx];611        if (ee == null) {612          return -idx - 1;613        } else if (pe.equals(ee)) {614          return idx;615        } else if (++idx == elements.length) {616          idx = 0;617        }618      }619    }620    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {621      throw new InvalidObjectException("not serial proxy");622    }623    private Object writeReplace() {624      Object[] array = new Object[size];625      int dest = 0;626      for (Object o : elements) {627        if (o != null) {628          array[dest++] = o;629        }630      }631      return new CollSer(CollSer.IMM_SET, array);632    }633  }634  // ---------- Map Implementations ----------635  @SuppressWarnings("unchecked")636  static <K, V> Map<K, V> emptyMap() {637    return (Map<K, V>) MapN.EMPTY_MAP;638  }639  abstract static class AbstractImmutableMap<K, V> extends AbstractMap<K, V> implements Serializable {640    @Override641    public void clear() {642      throw uoe();643    }644    @Override645    public V compute(K key, BiFunction<? super K, ? super V, ? extends V> rf) {646      throw uoe();647    }648    @Override649    public V computeIfAbsent(K key, Function<? super K, ? extends V> mf) {650      throw uoe();651    }652    @Override653    public V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> rf) {654      throw uoe();655    }656    @Override657    public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> rf) {658      throw uoe();659    }660    @Override661    public V put(K key, V value) {662      throw uoe();663    }664    @Override665    public void putAll(Map<? extends K, ? extends V> m) {666      throw uoe();667    }668    @Override669    public V putIfAbsent(K key, V value) {670      throw uoe();671    }672    @Override673    public V remove(Object key) {674      throw uoe();675    }676    @Override677    public boolean remove(Object key, Object value) {678      throw uoe();679    }680    @Override681    public V replace(K key, V value) {682      throw uoe();683    }684    @Override685    public boolean replace(K key, V oldValue, V newValue) {686      throw uoe();687    }688    @Override689    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> f) {690      throw uoe();691    }692  }693  static final class Map1<K, V> extends AbstractImmutableMap<K, V> {694    private final K k0;695    private final V v0;696    Map1(K k0, V v0) {697      this.k0 = Objects.requireNonNull(k0);698      this.v0 = Objects.requireNonNull(v0);699    }700    @Override701    public Set<Map.Entry<K, V>> entrySet() {702      return Jdk11.Set.of(new KeyValueHolder<>(k0, v0));703    }704    @Override705    public V get(Object o) {706      return o.equals(k0) ? v0 : null; // implicit nullcheck of o707    }708    @Override709    public boolean containsKey(Object o) {710      return o.equals(k0); // implicit nullcheck of o711    }712    @Override713    public boolean containsValue(Object o) {714      return o.equals(v0); // implicit nullcheck of o715    }716    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {717      throw new InvalidObjectException("not serial proxy");718    }719    private Object writeReplace() {720      return new CollSer(CollSer.IMM_MAP, k0, v0);721    }722    @Override723    public int hashCode() {724      return k0.hashCode() ^ v0.hashCode();725    }726  }727  /**728   * An array-based Map implementation. There is a single array "table" that729   * contains keys and values interleaved: table[0] is kA, table[1] is vA,730   * table[2] is kB, table[3] is vB, etc. The table size must be even. It must731   * also be strictly larger than the size (the number of key-value pairs contained732   * in the map) so that at least one null key is always present.733   * @param <K> the key type734   * @param <V> the value type735   */736  static final class MapN<K, V> extends AbstractImmutableMap<K, V> {737    // EMPTY_MAP may be initialized from the CDS archive.738    static Map<?, ?> EMPTY_MAP;739    static {740      // VM.initializeFromArchive(MapN.class);741      EMPTY_MAP = new MapN<>();742    }743    final Object[] table; // pairs of key, value744    final int size; // number of pairs745    MapN(Object... input) {746      if ((input.length & 1) != 0) { // implicit nullcheck of input747        throw new InternalError("length is odd");748      }749      size = input.length >> 1;750      int len = EXPAND_FACTOR * input.length;751      len = (len + 1) & ~1; // ensure table is even length752      table = new Object[len];753      for (int i = 0; i < input.length; i += 2) {754        @SuppressWarnings("unchecked")755        K k = Objects.requireNonNull((K) input[i]);756        @SuppressWarnings("unchecked")757        V v = Objects.requireNonNull((V) input[i + 1]);758        int idx = probe(k);759        if (idx >= 0) {760          throw new IllegalArgumentException("duplicate key: " + k);761        } else {762          int dest = -(idx + 1);763          table[dest] = k;764          table[dest + 1] = v;765        }766      }767    }768    @Override769    public boolean containsKey(Object o) {770      Objects.requireNonNull(o);771      return size > 0 && probe(o) >= 0;772    }773    @Override774    public boolean containsValue(Object o) {775      Objects.requireNonNull(o);776      for (int i = 1; i < table.length; i += 2) {777        Object v = table[i];778        if (v != null && o.equals(v)) {779          return true;780        }781      }782      return false;783    }784    @Override785    public int hashCode() {786      int hash = 0;787      for (int i = 0; i < table.length; i += 2) {788        Object k = table[i];789        if (k != null) {790          hash += k.hashCode() ^ table[i + 1].hashCode();791        }792      }793      return hash;794    }795    @Override796    @SuppressWarnings("unchecked")797    public V get(Object o) {798      if (size == 0) {799        Objects.requireNonNull(o);800        return null;801      }802      int i = probe(o);803      if (i >= 0) {804        return (V) table[i + 1];805      } else {806        return null;807      }808    }809    @Override810    public int size() {811      return size;812    }813    class MapNIterator implements Iterator<Map.Entry<K, V>> {814      private int remaining;815      private int idx;816      MapNIterator() {817        remaining = size();818        if (remaining > 0) {819          idx = Math.floorMod(SALT, table.length >> 1) << 1;820        }821      }822      @Override823      public boolean hasNext() {824        return remaining > 0;825      }826      private int nextIndex() {827        int idx = this.idx;828        if (SALT >= 0) {829          if ((idx += 2) >= table.length) {830            idx = 0;831          }832        } else {833          if ((idx -= 2) < 0) {834            idx = table.length - 2;835          }836        }837        return this.idx = idx;838      }839      @Override840      public Map.Entry<K, V> next() {841        if (hasNext()) {842          while (table[nextIndex()] == null) {}843          @SuppressWarnings("unchecked")844          Map.Entry<K, V> e = new KeyValueHolder<>((K) table[idx], (V) table[idx + 1]);845          remaining--;846          return e;847        } else {848          throw new NoSuchElementException();849        }850      }851    }852    @Override853    public Set<Map.Entry<K, V>> entrySet() {854      return new AbstractSet<Map.Entry<K, V>>() {855        @Override856        public int size() {857          return MapN.this.size;858        }859        @Override860        public Iterator<Map.Entry<K, V>> iterator() {861          return new MapNIterator();862        }863      };864    }865    // returns index at which the probe key is present; or if absent,866    // (-i - 1) where i is location where element should be inserted.867    // Callers are relying on this method to perform an implicit nullcheck868    // of pk.869    private int probe(Object pk) {870      int idx = Math.floorMod(pk.hashCode(), table.length >> 1) << 1;871      while (true) {872        @SuppressWarnings("unchecked")873        K ek = (K) table[idx];874        if (ek == null) {875          return -idx - 1;876        } else if (pk.equals(ek)) {877          return idx;878        } else if ((idx += 2) == table.length) {879          idx = 0;880        }881      }882    }883    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {884      throw new InvalidObjectException("not serial proxy");885    }886    private Object writeReplace() {887      Object[] array = new Object[2 * size];888      int len = table.length;889      int dest = 0;890      for (int i = 0; i < len; i += 2) {891        if (table[i] != null) {892          array[dest++] = table[i];893          array[dest++] = table[i + 1];894        }895      }896      return new CollSer(CollSer.IMM_MAP, array);897    }898  }899}900// ---------- Serialization Proxy ----------901/**902 * Copied from {@code java.util.CollSer}.903 * 904 * A unified serialization proxy class for the immutable collections.905 *906 * @serial907 * @since 9908 */909final class CollSer implements Serializable {910  private static final long serialVersionUID = 6309168927139932177L;911  static final int IMM_LIST = 1;912  static final int IMM_SET = 2;913  static final int IMM_MAP = 3;914  /**915   * Indicates the type of collection that is serialized.916   * The low order 8 bits have the value 1 for an immutable917   * {@code List}, 2 for an immutable {@code Set}, and 3 for918   * an immutable {@code Map}. Any other value causes an919   * {@link InvalidObjectException} to be thrown. The high920   * order 24 bits are zero when an instance is serialized,921   * and they are ignored when an instance is deserialized.922   * They can thus be used by future implementations without923   * causing compatibility issues.924   *925   * <p>The tag value also determines the interpretation of the926   * transient {@code Object[] array} field.927   * For {@code List} and {@code Set}, the array's length is the size928   * of the collection, and the array contains the elements of the collection.929   * Null elements are not allowed. For {@code Set}, duplicate elements930   * are not allowed.931   *932   * <p>For {@code Map}, the array's length is twice the number of mappings933   * present in the map. The array length is necessarily even.934   * The array contains a succession of key and value pairs:935   * {@code k1, v1, k2, v2, ..., kN, vN.} Nulls are not allowed,936   * and duplicate keys are not allowed.937   *938   * @serial939   * @since 9940   */941  private final int tag;...

size

Using AI Code Generation

1import org.assertj.core.test.jdk11.ImmutableCollections;2public class 1 {3    public static void main(String[] args) {4        ImmutableCollections immutableCollections = new ImmutableCollections();5        System.out.println(immutableCollections.size());6    }7}

size

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import org.assertj.core.test.jdk11.ImmutableCollections;3public class 1 {4    public static void main(String[] args) {5        ImmutableCollections immutableCollections = new ImmutableCollections();6        assertThat(immutableCollections.size()).isEqualTo(0);7    }8}9import static org.assertj.core.api.Assertions.assertThat;10import org.assertj.core.test.jdk8.ImmutableCollections;11public class 2 {12    public static void main(String[] args) {13        ImmutableCollections immutableCollections = new ImmutableCollections();14        assertThat(immutableCollections.size()).isEqualTo(0);15    }16}17        assertThat(immutableCollections.size()).isEqualTo(0);18  symbol:   method size()

size

Using AI Code Generation

1import org.assertj.core.test.jdk11.ImmutableCollections;2public class 1 {3  public static void main(String[] args) {4    ImmutableCollections immutableCollections = new ImmutableCollections();5    int size = immutableCollections.size();6    System.out.println("size: " + size);7  }8}

size

Using AI Code Generation

1import org.assertj.core.test.jdk11.ImmutableCollections;2class Test {3  public static void main(String[] args) {4    ImmutableCollections immutableCollections = new ImmutableCollections();5    System.out.println(immutableCollections.size());6  }7}8import org.assertj.core.test.jdk11.ImmutableCollections;9class Test {10  public static void main(String[] args) {11    ImmutableCollections immutableCollections = new ImmutableCollections();12    System.out.println(immutableCollections.size());13  }14}15import org.assertj.core.test.jdk11.ImmutableCollections;16class Test {17  public static void main(String[] args) {18    ImmutableCollections immutableCollections = new ImmutableCollections();19    System.out.println(immutableCollections.size());20  }21}22import org.assertj.core.test.jdk11.ImmutableCollections;23class Test {24  public static void main(String[] args) {25    ImmutableCollections immutableCollections = new ImmutableCollections();26    System.out.println(immutableCollections.size());27  }28}29import org.assertj.core.test.jdk11.ImmutableCollections;30class Test {31  public static void main(String[] args) {32    ImmutableCollections immutableCollections = new ImmutableCollections();33    System.out.println(immutableCollections.size());34  }35}36import org.assertj.core.test.jdk11.ImmutableCollections;37class Test {38  public static void main(String[] args) {39    ImmutableCollections immutableCollections = new ImmutableCollections();40    System.out.println(immutableCollections.size());41  }42}43import org.assertj.core.test.jdk11.ImmutableCollections;44class Test {45  public static void main(String[] args) {46    ImmutableCollections immutableCollections = new ImmutableCollections();47    System.out.println(immutableCollections.size());48  }49}50import

size

Using AI Code Generation

1import org.assertj.core.test.jdk11.ImmutableCollections;2import java.util.List;3public class 1 {4    public static void main(String[] args) {5        List<String> list = ImmutableCollections.of("one", "two");6        System.out.println(list.size());7    }8}9import org.assertj.core.test.jdk11.ImmutableCollections;10import java.util.List;11public class 2 {12    public static void main(String[] args) {13        List<String> list = ImmutableCollections.of("one", "two");14        System.out.println(list.size());15    }16}17import org.assertj.core.test.jdk11.ImmutableCollections;18import java.util.List;19public class 3 {20    public static void main(String[] args) {21        List<String> list = ImmutableCollections.of("one", "two");22        System.out.println(list.size());23    }24}25import org.assertj.core.test.jdk11.ImmutableCollections;26import java.util.List;27public class 4 {28    public static void main(String[] args) {29        List<String> list = ImmutableCollections.of("one", "two");30        System.out.println(list.size());31    }32}33import org.assertj.core.test.jdk11.ImmutableCollections;34import java.util.List;35public class 5 {36    public static void main(String[] args) {37        List<String> list = ImmutableCollections.of("one", "two");38        System.out.println(list.size());39    }40}41import org.assertj.core.test.jdk11.ImmutableCollections;42import java.util.List;43public class 6 {44    public static void main(String[] args) {45        List<String> list = ImmutableCollections.of("one", "two");46        System.out.println(list.size());47    }48}49import org.assertj.core.test.jdk11.ImmutableCollections;50import

size

Using AI Code Generation

1import org.assertj.core.test.jdk11.ImmutableCollections;2import java.util.List;3import java.util.Map;4import java.util.Set;5public class 1 {6public static void main(String[] args) {7List<String> list = ImmutableCollections.listOf("one", "two");8Set<String> set = ImmutableCollections.setOf("one", "two");9Map<String, String> map = ImmutableCollections.mapOf("one", "two");10}11}12ImmutableCollections.size() Method13public static <T> int size(Collection<T> collection)14Example: Using size() Method of ImmutableCollections Class15import org.assertj.core.test.jdk11.ImmutableCollections;16import java.util.List;17import java.util.Map;18import java.util.Set;19public class 2 {20public static void main(String[] args) {21List<String> list = ImmutableCollections.listOf("one", "two");22Set<String> set = ImmutableCollections.setOf("one", "two");23Map<String, String> map = ImmutableCollections.mapOf("one", "two");24}25}26ImmutableCollections.putAll() Method27public static <K, V> void putAll(Map<K, V> map, Map<K, V> mapToPut)

size

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.test.jdk11.ImmutableCollections.size;3public class 1 {4    public static void main(String[] args) {5        assertThat(size()).isEqualTo(0);6    }7}8	at 1.main(1.java:7)

size

Using AI Code Generation

1import org.assertj.core.test.jdk11.ImmutableCollections;2public class Test {3public static void main(String[] args) {4ImmutableCollections immutableCollections = new ImmutableCollections();5System.out.println(immutableCollections.size());6}7}8import org.assertj.core.test.jdk11.ImmutableCollections;9public class Test {10public static void main(String[] args) {11ImmutableCollections immutableCollections = new ImmutableCollections();12System.out.println(immutableCollections.size());13}14}15import org.assertj.core.test.jdk11.ImmutableCollections;16public class Test {17public static void main(String[] args) {18ImmutableCollections immutableCollections = new ImmutableCollections();19System.out.println(immutableCollections.size());20}21}22import org.assertj.core.test.jdk11.ImmutableCollections;23public class Test {24public static void main(String[] args) {25ImmutableCollections immutableCollections = new ImmutableCollections();26System.out.println(immutableCollections.size());27}28}29import org.assertj.core.test.jdk11.ImmutableCollections;30public class Test {31public static void main(String[] args) {32ImmutableCollections immutableCollections = new ImmutableCollections();33System.out.println(immutableCollections.size());34}35}36import org.assertj.core.test.jdk11.ImmutableCollections;37public class Test {38public static void main(String[] args) {39ImmutableCollections immutableCollections = new ImmutableCollections();40System.out.println(immutableCollections.size());41}42}43import org.assertj.core.test.jdk11.ImmutableCollections;44public class Test {45public static void main(String[] args) {46ImmutableCollections immutableCollections = new ImmutableCollections();47System.out.println(immutableCollections.size());48}49}50import

size

Using AI Code Generation

1import org.assertj.core.test.jdk11.ImmutableCollections;2public class 1 {3   public static void main(String[] args) {4      ImmutableCollections immutableCollections = new ImmutableCollections();5      immutableCollections.size();6   }7}8import org.assertj.core.test.jdk11.ImmutableCollections;9public class 2 {10   public static void main(String[] args) {11      ImmutableCollections immutableCollections = new ImmutableCollections();12      immutableCollections.size();13   }14}15import org.assertj.core.test.jdk11.ImmutableCollections;16public class 3 {17   public static void main(String[] args) {18      ImmutableCollections immutableCollections = new ImmutableCollections();19      immutableCollections.size();20   }21}22import org.assertj.core.test.jdk11.ImmutableCollections;23public class 4 {24   public static void main(String[] args) {25      ImmutableCollections immutableCollections = new ImmutableCollections();26      immutableCollections.size();27   }28}29import org.assertj.core.test.jdk11.ImmutableCollections;30public class 5 {31   public static void main(String[] args) {32      ImmutableCollections immutableCollections = new ImmutableCollections();33      immutableCollections.size();34   }35}36import org.assertj.core.test.jdk11.ImmutableCollections;37public class 6 {38   public static void main(String[] args) {39      ImmutableCollections immutableCollections = new ImmutableCollections();40      immutableCollections.size();41   }42}43import org.assertj.core.test.jdk11.ImmutableCollections;

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.