// failure policy.
  // The timeout value must be between 1 and 30 seconds.
  // Default to 10 seconds.
  // +optional
  optional int32 timeoutSeconds = 7;

  // AdmissionReviewVersions is an ordered list of preferred `AdmissionReview`
  // versions the Webhook expects. API server will try to use first version in
  // the list which it supports. If none of the versions specified in this list

    assertThat(Floats.join("", (float) 1, (float) 2, (float) 3)).isEqualTo("1.02.03.0");
  }

  public void testLexicographicalComparator() {
    List<float[]> ordered =
        Arrays.asList(
            new float[] {},
            new float[] {LEAST},
            new float[] {LEAST, LEAST},
            new float[] {LEAST, (float) 1},
            new float[] {(float) 1},

    assertThat(Ints.join(",", (int) 1, (int) 2)).isEqualTo("1,2");
    assertThat(Ints.join("", (int) 1, (int) 2, (int) 3)).isEqualTo("123");
  }

  public void testLexicographicalComparator() {
    List<int[]> ordered =
        Arrays.asList(
            new int[] {},
            new int[] {LEAST},
            new int[] {LEAST, LEAST},
            new int[] {LEAST, (int) 1},
            new int[] {(int) 1},

    assertThat(Doubles.join(",", 1.3, 2.4)).isEqualTo("1.3,2.4");
    assertThat(Doubles.join("", 1.4, 2.5, 3.6)).isEqualTo("1.42.53.6");
  }

  public void testLexicographicalComparator() {
    List<double[]> ordered =
        Arrays.asList(
            new double[] {},
            new double[] {LEAST},
            new double[] {LEAST, LEAST},
            new double[] {LEAST, (double) 1},
            new double[] {(double) 1},

    assertThat(Floats.join("", (float) 1, (float) 2, (float) 3)).isEqualTo("1.02.03.0");
  }

  public void testLexicographicalComparator() {
    List<float[]> ordered =
        Arrays.asList(
            new float[] {},
            new float[] {LEAST},
            new float[] {LEAST, LEAST},
            new float[] {LEAST, (float) 1},
            new float[] {(float) 1},

    assertThat(Longs.join(",", (long) 1, (long) 2)).isEqualTo("1,2");
    assertThat(Longs.join("", (long) 1, (long) 2, (long) 3)).isEqualTo("123");
  }

  public void testLexicographicalComparator() {
    List<long[]> ordered =
        Arrays.asList(
            new long[] {},
            new long[] {MIN_VALUE},
            new long[] {MIN_VALUE, MIN_VALUE},
            new long[] {MIN_VALUE, (long) 1},
            new long[] {(long) 1},

    }
  }

  /**
   * A means for changing an Ordering into another Ordering. Each instance is responsible for
   * creating the alternate Ordering, and providing a List that is known to be ordered, based on an
   * input List known to be ordered according to the input Ordering.
   */
  private enum OrderingMutation {
    REVERSE {
      @Override
      <T extends @Nullable Object> Scenario<?> mutate(Scenario<T> scenario) {

    }
  }

  /**
   * A means for changing an Ordering into another Ordering. Each instance is responsible for
   * creating the alternate Ordering, and providing a List that is known to be ordered, based on an
   * input List known to be ordered according to the input Ordering.
   */
  private enum OrderingMutation {
    REVERSE {
      @Override
      <T extends @Nullable Object> Scenario<?> mutate(Scenario<T> scenario) {

			c = d.skipSpaces()
			goto scan
		default:
			err = d.mkError(ErrSyntax, "after object key:value pair")
			goto out
		}
	}

out:
	d.depth--
	return obj, err
}

// object (ordered) accept valid JSON array value
func (d *Decoder) objectOrdered() (KVS, error) {
	d.depth++
	if d.maxDepth > 0 && d.depth > d.maxDepth {
		return nil, ErrMaxDepth
	}

	var (
		c   byte
		k   string

   */
  Spliterator.OfLong spliterator() {
    return Spliterators.spliterator(array, start, end, Spliterator.IMMUTABLE | Spliterator.ORDERED);
  }

  /**
   * Returns an immutable <i>view</i> of this array's values as a {@code List}; note that {@code
   * long} values are boxed into {@link Long} instances on demand, which can be very expensive. The