}

    try {
      striped.getAt(-1);
      fail();
    } catch (RuntimeException expected) {
    }

    try {
      striped.getAt(striped.size());
      fail();
    } catch (RuntimeException expected) {
    }
  }

  public void testMaxSize() {
    for (Striped<?> striped :
        ImmutableList.of(

                        errors.put(file, Set.of("Expected an object, but found: " + jsonNode.getNodeType()));
                        return;
                    }

                    final ObjectNode rootNode = (ObjectNode) jsonNode;

                    if (rootNode.size() != 1) {
                        errors.put(file, Set.of("Expected an object with exactly 1 key, but found " + rootNode.size() + " keys"));

        new ActivationProperty().equals(new ActivationProperty());
    }

    @Test
    void testEqualsIdentity() {
        ActivationProperty thing = new ActivationProperty();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new ActivationProperty().toString());
    }

        new Developer().equals(new Developer());
    }

    @Test
    void testEqualsIdentity() {
        Developer thing = new Developer();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Developer().toString());
    }

        new Parent().equals(new Parent());
    }

    @Test
    void testEqualsIdentity() {
        Parent thing = new Parent();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Parent().toString());
    }

        new Prerequisites().equals(new Prerequisites());
    }

    @Test
    void testEqualsIdentity() {
        Prerequisites thing = new Prerequisites();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Prerequisites().toString());
    }

        assertFalse(new Site().equals(null));

        new Site().equals(new Site());
    }

    @Test
    void testEqualsIdentity() {
        Site thing = new Site();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Site().toString());
    }

      return null;
    }
  }

  @GwtIncompatible // Doubles.tryParse
  private static void checkTryParse(String input) {
    Double expected = referenceTryParse(input);
    assertThat(Doubles.tryParse(input)).isEqualTo(expected);
    if (expected != null && !Doubles.FLOATING_POINT_PATTERN.matcher(input).matches()) {
      // TODO(cpovirk): Use SourceCodeEscapers if it is added to Guava.

            // throws immediately with empty field name, we need to catch it here
            fail("Expected an exception for empty field name");
        } catch (IllegalArgumentException e) {
            // Expected exception for empty field name
            assertTrue(e.getMessage().contains("field name is null or empty"));
        }

                        for (final String expectedLine : expectedLines) {
                            if (actualLines.contains(expectedLine) == false) {
                                throw new GradleException("expected [" + noticePath + " to contain [" + expectedLine + "] but it did not");
                            }
                        }
                    } catch (IOException ioException) {