public void testModifications() throws Exception {
    ConnectionObserver testObserver =
        new ConnectionObserver() {
          public void connectionLost(SocketAddress sa) {
            // none
          }

          public void connectionEstablished(SocketAddress sa, int reconnectCount) {
            // none
          }
        };
    BlockingQueue<Operation> oQueue = new LinkedBlockingQueue<Operation>();
    BlockingQueue<Operation> rQueue = new LinkedBlockingQueue<Operation>();
    BlockingQueue<Operation> wQueue = new LinkedBlockingQueue<Operation>();

    OperationQueueFactory opQueueFactory = new DirectFactory(oQueue);
    OperationQueueFactory rQueueFactory = new DirectFactory(rQueue);
    OperationQueueFactory wQueueFactory = new DirectFactory(wQueue);
    AuthDescriptor anAuthDescriptor =
        new AuthDescriptor(
            new String[] {"PLAIN"}, new PlainCallbackHandler("username", "password"));

    ConnectionFactory f =
        b.setDaemon(true)
            .setShouldOptimize(false)
            .setFailureMode(FailureMode.Redistribute)
            .setHashAlg(DefaultHashAlgorithm.KETAMA_HASH)
            .setInitialObservers(Collections.singleton(testObserver))
            .setOpFact(new BinaryOperationFactory())
            .setOpTimeout(4225)
            .setOpQueueFactory(opQueueFactory)
            .setReadOpQueueFactory(rQueueFactory)
            .setWriteOpQueueFactory(wQueueFactory)
            .setReadBufferSize(19)
            .setTranscoder(new WhalinTranscoder())
            .setUseNagleAlgorithm(true)
            .setLocatorType(Locator.CONSISTENT)
            .setOpQueueMaxBlockTime(19)
            .setAuthDescriptor(anAuthDescriptor)
            .build();

    assertEquals(4225, f.getOperationTimeout());
    assertEquals(19, f.getReadBufSize());
    assertSame(DefaultHashAlgorithm.KETAMA_HASH, f.getHashAlg());
    assertTrue(f.getDefaultTranscoder() instanceof WhalinTranscoder);
    assertSame(FailureMode.Redistribute, f.getFailureMode());
    assertEquals(1, f.getInitialObservers().size());
    assertSame(testObserver, f.getInitialObservers().iterator().next());
    assertTrue(f.getOperationFactory() instanceof BinaryOperationFactory);
    assertSame(oQueue, f.createOperationQueue());
    assertSame(rQueue, f.createReadOperationQueue());
    assertSame(wQueue, f.createWriteOperationQueue());
    assertTrue(f.isDaemon());
    assertFalse(f.shouldOptimize());
    assertTrue(f.useNagleAlgorithm());
    assertEquals(f.getOpQueueMaxBlockTime(), 19);
    assertSame(anAuthDescriptor, f.getAuthDescriptor());

    MemcachedNode n =
        new MockMemcachedNode(
            InetSocketAddress.createUnresolved("localhost", TestConfig.PORT_NUMBER));
    assertTrue(f.createLocator(Collections.singletonList(n)) instanceof KetamaNodeLocator);

    final MemcachedNode testNode =
        f.createMemcachedNode(
            InetSocketAddress.createUnresolved("localhost", TestConfig.PORT_NUMBER), 1);
    try {
      assertTrue(testNode instanceof BinaryMemcachedNodeImpl);
    } finally {
      testNode.getChannel().close();
    }
  }