assertTrue(observed.contains(striped.get(new Object())));
    }

    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(

     * new String[] { "SRV" }
     * );
     * return name;
     * } catch (NameNotFoundException nnfe) {
     * uhe = new UnknownHostException(nnfe.getMessage());
     * }
     * int dot = name.indexOf('.');
     * if (dot == -1)
     * break;
     * name = name.substring(dot + 1);
     * }
     * } catch (NamingException ne) {
     * if (log.level > 1)
     * ne.printStackTrace(log);
     * }

      try {
        writer.windowUpdate(streamId, unacknowledgedBytesRead)
      } catch (e: IOException) {
        failConnection(e)
      }
    }
  }

  fun writePing(
    reply: Boolean,
    payload1: Int,
    payload2: Int,
  ) {
    try {
      writer.ping(reply, payload1, payload2)
    } catch (e: IOException) {
      failConnection(e)
    }
  }

    } catch (UnsupportedOperationException expected) {
    }
    try {
      unmod.remove(4);
      fail("UnsupportedOperationException expected");
    } catch (UnsupportedOperationException expected) {
    }
    try {
      unmod.addAll(singleton(4));
      fail("UnsupportedOperationException expected");
    } catch (UnsupportedOperationException expected) {
    }

                if (dirents[i].getType() == SmbFile.TYPE_NAMED_PIPE) {
                    continue;
                }
            } catch (final SmbAuthException sae) {
                if (LogStream.level > 2) {
                    sae.printStackTrace(log);
                }
            } catch (final SmbException se) {
                if (LogStream.level > 2) {
                    se.printStackTrace(log);
                }

          state = STATE_READ_RESPONSE_HEADERS
          responseBuilder
        }
        else -> {
          state = STATE_OPEN_RESPONSE_BODY
          responseBuilder
        }
      }
    } catch (e: EOFException) {
      // Provide more context if the server ends the stream before sending a response.
      val address =
        carrier.route.address.url
          .redact()

            fail("Should throw exception");
        } catch (Exception e) {
            // Expected
        }
    }

    public void test_getJobExecutor_withoutSuffix() {
        try {
            ComponentUtil.getJobExecutor("test");
            fail("Should throw exception");
        } catch (Exception e) {
            // Expected
        }
    }

          getMap()
              .computeIfAbsent(
                  k0(),
                  k -> {
                    assertEquals(k0(), k);
                    return v0();
                  }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

            try {
                String version = resolveVersion(artifact, request);
                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

    @Override

        while (clazz != null) {
            try {
                Field f = clazz.getDeclaredField(fieldName);
                f.setAccessible(true);
                return f.get(target);
            } catch (NoSuchFieldException e) {
                clazz = clazz.getSuperclass();
            }
        }
        throw new NoSuchFieldException(fieldName);
    }