} catch (e: AssertionError) {
    throw e
  } catch (rethrown: RuntimeException) {
    if (rethrown.message == "bio == null") {
      // Conscrypt in Android 10 and 11 may throw closing an SSLSocket. This is safe to ignore.
      // https://issuetracker.google.com/issues/177450597
      return
    }
    throw rethrown
  } catch (_: Exception) {
  }
}

/** Closes this, ignoring any checked exceptions.  */

                            try {
                                entry.setValue(interpolated);
                            } catch (UnsupportedOperationException ignore) {
                                // nop
                            }
                        }
                    } else if (value.getClass().isArray()) {
                        evaluateArray(value, ctx);

* kubectl: ignore only update conflicts in the scaler ([#27048](https://github.com/kubernetes/kubernetes/pull/27048), [@kargakis](https://github.com/kargakis))
* Declare out of disk when there is no free inodes ([#28176](https://github.com/kubernetes/kubernetes/pull/28176), [@ronnielai](https://github.com/ronnielai))

    void testReservedBytesSkipped(byte reservedValue) throws Exception {
        byte[] buffer = new byte[100];
        int bufferIndex = 0;

        // Set reserved bytes to non-zero values (should be ignored)
        buffer[bufferIndex] = reservedValue;
        buffer[bufferIndex + 1] = reservedValue;
        buffer[bufferIndex + 2] = reservedValue;

        // Set valid data for other fields

          continue;
        }
        responseQueue.put(new Response(request.methodName, result, null));
      }
    } catch (ThreadDeath death) {
      return;
    } catch (InterruptedException ignored) {
      // SynchronousQueue sometimes throws InterruptedException while the threads are stopping.
    } catch (Throwable uncaught) {
      this.uncaughtThrowable = uncaught;
    }
  }

                try {
                    requestManager.findLoginManager(FessUserBean.class).ifPresent(LoginManager::logout);
                } catch (final Exception e1) {
                    // ignore
                }
                throw e;
            }
        }

        if (defaultRoleList != null) {
            roleSet.addAll(defaultRoleList);
        }

    assertThat(stats.loadSuccessCount()).isEqualTo(4);
    assertThat(stats.loadExceptionCount()).isEqualTo(0);
    assertThat(stats.hitCount()).isEqualTo(3);

    // duplicate keys are ignored, and don't impact stats
    assertThat(cache.getAll(asList(4, 5))).containsExactly(4, 4, 5, 5);
    stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(5);
    assertThat(stats.loadSuccessCount()).isEqualTo(5);

        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (final IOException e) {
                    // ignore
                }
            }
        }
        lastModified = propertiesFile.lastModified();
    }

    /**
     * Returns the current properties, reloading them if the file has been updated.

                            try {
                                keyManager.rotateSessionKey(sid);
                            } catch (GeneralSecurityException e) {
                                // Ignore in concurrent test
                            }
                        }
                    }
                } finally {
                    latch.countDown();
                }
            });

        // TODO
        try {
            Class.forName("org.apache.commons.logging.LogFactory");
            return new JclLoggerAdapterFactory();
        } catch (final Throwable ignore) {
            return new JulLoggerAdapterFactory();
        }
    }

    /**
     * Constructs an instance.
     *
     * @param clazz
     *            The class to be used as the logging category.