failures before ejection occurs.
                              maximum: 4294967295
                              minimum: 0
                              nullable: true
                              type: integer
                            interval:
                              description: Time interval between ejection sweep analysis.
                              type: string

      if (length != 4) throw IOException("TYPE_WINDOW_UPDATE length !=4: $length")
      increment = source.readInt() and 0x7fffffffL
      if (increment == 0L) throw IOException("windowSizeIncrement was 0")
    } catch (e: Exception) {
      logger.fine(frameLog(true, streamId, length, TYPE_WINDOW_UPDATE, flags))
      throw e
    }
    if (logger.isLoggable(FINE)) {
      logger.fine(
        frameLogWindowUpdate(

                    Thread.sleep(100)
                  }
                } catch (e: IOException) {
                  log.add(e.toString())
                  throw e
                } catch (e: Exception) {
                  log.add(e.toString())
                }
              }
            },
          )
          .build(),
      )
    call.execute().use { response ->

  private PairedStatsAccumulator constantValuesAccumulator;
  private PairedStatsAccumulator constantValuesAccumulatorByAddAllPartitionedPairedStats;

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    emptyAccumulator = new PairedStatsAccumulator();

    emptyAccumulatorByAddAllEmptyPairedStats = new PairedStatsAccumulator();

import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.Properties;

import org.codelibs.core.exception.IORuntimeException;
import org.codelibs.core.net.URLUtil;

/**
 * {@link Properties}用のユーティリティクラスです。
 *
 * @author higa
 */
public abstract class PropertiesUtil {

    /**

    // Added by cgross to work with weblogic 6.1.
    /**
     * @param f
     */
    public void setFilterConfig ( FilterConfig f ) {
        try {
            init(f);
        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
    }


    /**
     * @return filter config
     */
    public FilterConfig getFilterConfig () {
        return null;
    }

                try {
                    KerberosPrincipal entry = (KerberosPrincipal) ite.next();
                    return entry.getRealm();
                }
                catch ( Exception e ) {
                    continue;
                }
            }
        }

        if ( this.realm != null ) {
            return this.realm;
        }

        return super.getUserDomain();

With the Dependency Injection system, you can also tell **FastAPI** that your *path operation function* also "depends" on something else that should be executed before your *path operation function*, and **FastAPI** will take care of executing it and "injecting" the results.

Other common terms for this same idea of "dependency injection" are:

* resources
* providers
* services
* injectables
* components

## **FastAPI** plug-ins

        modelMerger.merge( target, source, false, null );
        assertThat( target.getVersion(), is( "TARGET" ) );
    }

    @Test
    public void testMergedModelSerialization() throws Exception {
        Model target = new Model();
        Model source = new Model();
        target.setLicenses(new ArrayList<License>());
        License lic1 = new License();
        License lic2 = new License();

    CharBuffer empty = CharBuffer.wrap("");
    assertEquals(0, CharStreams.exhaust(empty));
    assertEquals(0, empty.remaining());
  }

  public void testNullWriter() throws Exception {
    // create a null writer
    Writer nullWriter = CharStreams.nullWriter();
    // write to the writer
    nullWriter.write('n');
    String test = "Test string for NullWriter";
    nullWriter.write(test);