// Retention configuration, needed to be passed along with lifecycle if set.
	Retention lock.Retention `msg:"-"`

	// Replication configuration
	Replication replicationConfig `msg:"-"`

	// StopDiskAtLimit will stop listing on each disk when limit number off objects has been returned.
	StopDiskAtLimit bool

	// pool and set of where the cache is located.
	pool, set int
}

func init() {
	gob.Register(listPathOptions{})

				return
			}
		case "pool":
			z.pool, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "pool")
				return
			}
		case "set":
			z.set, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "set")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));
    assertTrue(set.contains(3));
    assertFalse(set.contains(4));
    set = ContiguousSet.create(Range.open(0, 4), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));

    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));
    assertTrue(set.contains(3));
    assertFalse(set.contains(4));
    set = ContiguousSet.create(Range.open(0, 4), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));

                  @Override
                  protected Set<String> create(String[] elements) {
                    Set<String> set = Sets.newHashSet("b", "c");
                    Set<String> other = Sets.newHashSet("a", "b", "c", "d");
                    return Sets.difference(set, other);
                  }
                })
            .named("set - superset")
            .withFeatures(

  /**
   * Returns a {@link Set} whose methods throw {@link IllegalStateException} when the given node is
   * not present in this network.
   *
   * @since 33.1.0
   */
  protected final <T> Set<T> nodeInvalidatableSet(Set<T> set, N node) {
    return InvalidatableSet.of(
        set, () -> nodes().contains(node), () -> String.format(NODE_REMOVED_FROM_GRAPH, node));
  }

  /**

  }

  public void testEmpty_comparator() {
    SortedSet<String> set = of();
    assertSame(Ordering.natural(), set.comparator());
  }

  public void testEmpty_headSet() {
    SortedSet<String> set = of();
    assertSame(set, set.headSet("c"));
  }

  public void testEmpty_tailSet() {
    SortedSet<String> set = of();
    assertSame(set, set.tailSet("f"));
  }

  public void testEmpty_subSet() {

      }
    }
    return features;
  }

  /**
   * Given a set of features, return a new set of all features directly or indirectly implied by any
   * of them.
   *
   * @param features the set of features whose implications to find
   * @return the implied set of features
   */
  public static Set<Feature<?>> impliedFeatures(Set<Feature<?>> features) {
    Set<Feature<?>> impliedSet = new LinkedHashSet<>();

                  @Override
                  protected Set<String> create(String[] elements) {
                    Set<String> set = Sets.newHashSet("b", "c");
                    Set<String> other = Sets.newHashSet("a", "b", "c", "d");
                    return Sets.difference(set, other);
                  }
                })
            .named("set - superset")
            .withFeatures(

    Set<String> set = of("a", "b");
    assertEquals(Sets.newHashSet("a", "b"), set);
  }

  public void testCreation_threeElements() {
    Set<String> set = of("a", "b", "c");
    assertEquals(Sets.newHashSet("a", "b", "c"), set);
  }

  public void testCreation_fourElements() {
    Set<String> set = of("a", "b", "c", "d");
    assertEquals(Sets.newHashSet("a", "b", "c", "d"), set);
  }