public CuratorFrameworkImpl(CuratorFrameworkFactory.Builder builder)
        {
            IZookeeperFactory localZookeeperFactory = makeZookeeperFactory(builder.GetZookeeperFactory());
            this.client = new CuratorZookeeperClient(localZookeeperFactory,
                                                        builder.GetEnsembleProvider(),
                                                        builder.GetSessionTimeoutMs(),
                                                        builder.GetConnectionTimeoutMs(),
                                                        new WatchedWatcher(this),
                                                        builder.GetRetryPolicy(),
                                                        builder.CanBeReadOnly());

            listeners = new ListenerContainer<ICuratorListener>();
            unhandledErrorListeners = new ListenerContainer<IUnhandledErrorListener>();
            backgroundOperations = new DelayQueue<OperationAndData<object>>();
            @namespace = new NamespaceImpl(this, builder.GetNamespace());
            maxCloseWaitMs = builder.GetMaxCloseWaitMs();
            connectionStateManager = new ConnectionStateManager(this, builder.GetEventQueueSize());
            compressionProvider = builder.GetCompressionProvider();
            aclProvider = builder.GetAclProvider();
            state = new AtomicReference<CuratorFrameworkState>(CuratorFrameworkState.LATENT);
            useContainerParentsIfAvailable = builder.UseContainerParentsIfAvailable();

            byte[] builderDefaultData = builder.GetDefaultData();
            byte[] destDefaults = new byte[builderDefaultData.Length];
            Array.Copy(builderDefaultData, destDefaults, builderDefaultData.Length);
            defaultData = (builderDefaultData != null)
                            ?  destDefaults
                            : new byte[0];
            authInfos = buildAuths(builder);

            failedDeleteManager = new FailedDeleteManager(this);
            namespaceWatcherMap = new NamespaceWatcherMap(this);
            namespaceFacadeCache = new NamespaceFacadeCache(this);
        }

        public void CompareAndSet_when_equal_returns_true()
        {
            var expected = new object();
            var obj = new AtomicReference<object>(expected);

            Assert.IsTrue(obj.CompareAndSet(expected, new object()));
        }

        public void ToString_returns_a_string_representation_of_the_object()
        {
            var shared = new AtomicReference<object>();

            const string expected = "AtomicReference<System.Object>";

            Assert.AreEqual(expected, shared.ToString());
        }

        public void AtomicReference_IEquatable_Of_Ref_Should_Compare()
        {
            IEquatable<object> firstAtomic = new AtomicReference<object>(new object());
            IEquatable<object> secondAtomic = new AtomicReference<object>(null);

            Assert.False(firstAtomic.Equals(false));
            Assert.False(secondAtomic.Equals(true));
        }

        public void GetAndSet_sets_new_value()
        {
            var obj = new AtomicReference<object>();
            var value = new object();

            obj.GetAndSet(value);

            Assert.AreEqual(value, obj.Value);
        }

        public void GetAndSet_returns_old_value()
        {
            var value = new object();
            var obj = new AtomicReference<object>(value);

            var actual = obj.GetAndSet(new object());

            Assert.AreEqual(value, actual);
        }

        public void Constructor_when_given_a_value_instantiates_with_it()
        {
            var value = new object();
            var obj = new AtomicReference<object>(value);

            var actual = obj.Value;

            Assert.AreEqual(value, actual);
        }

 /// <summary>
 /// Initialize a reference to an on-disk object directory.
 /// </summary>
 /// <param name="dir">the location of the <code>objects</code> directory.</param>
 /// <param name="alternateObjectDir">a list of alternate object directories</param>
 public ObjectDirectory(DirectoryInfo dir, DirectoryInfo[] alternateObjectDir)
 {
     _objects = dir;
     _alternateObjectDir = alternateObjectDir;
     _infoDirectory = new DirectoryInfo(_objects.FullName + "/info");
     _packDirectory = new DirectoryInfo(_objects.FullName + "/pack");
     _alternatesFile = new FileInfo(_infoDirectory + "/alternates");
     _packList = new AtomicReference<PackList>(NoPacks);
 }

        public void CompareAndSet_when_not_equal_does_not_set_value()
        {
            var initial = new object();
            var obj = new AtomicReference<object>(initial);

            obj.CompareAndSet(new object(), new object());

            Assert.AreEqual(initial, obj.Value);
        }

 protected EnsurePath(String path, 
                         AtomicReference<Helper> helper, 
                         bool makeLastNode, 
                         IInternalACLProvider aclProvider)
 {
     this.path = path;
     this.makeLastNode = makeLastNode;
     this.aclProvider = aclProvider;
     this.helper = helper ?? new AtomicReference<Helper>(new InitialHelper(this));
 }

        public void AtomicReference_Implicit_Reassignment_Should_Change_Reference()
        {
            var firstAtomic = new AtomicReference<object>(new object());
            var secondAtomic = firstAtomic;

            firstAtomic = false;

            Assert.NotEqual(secondAtomic, firstAtomic);
            Assert.False(object.ReferenceEquals(secondAtomic, firstAtomic));
        }

        public void AtomicReference_Implicit_Ref_AcqRel_Should_Success()
        {
            var source = new object();
            var atomicReference = new AtomicReference<object>(source);

            var func = new Func<object, object>(i => i);

            Assert.NotEqual(source, func(atomicReference));
            Assert.Equal(source, func(atomicReference.Value));
        }

    public void ShouldExchangeAndReturnOldValue() {
      ReferenceMock reference = Reference;

      AtomicReference<ReferenceMock> ar =
        new AtomicReference<ReferenceMock>(reference);

      ReferenceMock new_mock = new ReferenceMock("new_mock");
      ReferenceMock old_mock = ar.Exchange(new_mock);
      Assert.AreEqual(new_mock, ar.Value);
      Assert.AreEqual(reference, old_mock);
    }

    public void ShouldNotUpdateWhenComparisonIsFalseAndReturnOldValue() {
      ReferenceMock reference = Reference;

      AtomicReference<ReferenceMock> ar =
        new AtomicReference<ReferenceMock>(reference);

      ReferenceMock new_mock = new ReferenceMock("new-mock");
      ReferenceMock old_mock = ar.CompareExchange(new_mock, new_mock);
      Assert.AreEqual(reference, ar.Value);
      Assert.AreEqual(reference, old_mock);
    }

        public void AtomicReference_Should_Implement_Reference_Equality()
        {
            var firstAtomic = new AtomicReference<object>(new object());
            var secondAtomic = new AtomicReference<object>(null);

            Assert.False(firstAtomic.Equals(secondAtomic));
            Assert.False(secondAtomic.Equals(firstAtomic));

            // self equality
            Assert.True(firstAtomic.Equals(firstAtomic));
            Assert.True(secondAtomic.Equals(secondAtomic));
        }

 public void Cache_should_be_updated_with_the_latest_resolved()
 {
     var localClock = new AtomicReference<long>(0);
     var cache = new SimpleDnsCacheTestDouble(localClock);
     var cacheEntryOne = Dns.Resolved.Create("test.local", System.Net.Dns.GetHostEntry("127.0.0.1").AddressList);
     var cacheEntryTwo = Dns.Resolved.Create("test.local", System.Net.Dns.GetHostEntry("127.0.0.1").AddressList);
     long ttl = 500;
     cache.Put(cacheEntryOne, ttl);
     cache.Cached("test.local").ShouldBe(cacheEntryOne);
     cache.Put(cacheEntryTwo, ttl);
     cache.Cached("test.local").ShouldBe(cacheEntryTwo);
 }

        public async Task TcpSocketChannel_should_not_throw_on_shutdown()
        {
            AtomicReference<Exception> clientError = new AtomicReference<Exception>(null);
            AtomicReference<Exception> serverError = new AtomicReference<Exception>(null);

            IChannel s = null;
            IChannel c = null;
            try
            {
                var sb = new ServerBootstrap()
                    .Channel<TcpServerSocketChannel>()
                    .ChildHandler(
                        new ActionChannelInitializer<TcpSocketChannel>(
                            channel => { channel.Pipeline.AddLast(new FailAssertionHandler(serverError)); }))
                    .Group(_serverGroup);

                s = sb.BindAsync(new IPEndPoint(IPAddress.IPv6Loopback, 0)).Result;


                var cb = new ClientBootstrap()
                    .Channel<TcpSocketChannel>()
                    .Option(ChannelOption.TcpNodelay, true)
                    .Option(ChannelOption.ConnectTimeout, TimeSpan.FromMilliseconds(100))
                    .Handler(
                        new ActionChannelInitializer<TcpSocketChannel>(
                            channel => { channel.Pipeline.AddLast(new FailAssertionHandler(clientError)); }))
                    .Group(_clientGroup);

                var clientEp = s.LocalAddress;
                c = cb.ConnectAsync(clientEp).Result;
                c.WriteAndFlushAsync(Unpooled.Buffer(4).WriteInt(2)).Wait(20);
                Assert.True(c.IsOpen);
                await c.CloseAsync();

                // assert that the counters were never decremented
                Assert.True(clientError.Value == null,
                    $"Expected null but error on client was {clientError.Value?.Message} {clientError.Value?.StackTrace}");
                Assert.True(serverError.Value == null,
                    $"Expected null but error on server was {serverError.Value?.Message} {serverError.Value?.StackTrace}");
            }
            finally
            {
                try
                {
                    c?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
                    s?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
                }
                catch
                {
                }
            }
        }

 public void TestHandlerAddedExecutedInEventLoop(int timeout)
 {
     var latch = new CountdownEvent(1);
     var ex = new AtomicReference<Exception>();
     IChannelHandler handler = new ChannelHandler3(latch, ex);
     var channel = new EmbeddedChannel(handler);
     Assert.False(channel.Finish());
     Assert.True(latch.Wait(timeout));
     var cause = ex.Value;
     if (cause != null)
     {
         throw cause;
     }
 }

        public void Cache_should_not_reply_with_expired_but_not_yet_swept_out_entries()
        {
            var localClock = new AtomicReference<long>(0);
            var cache = new SimpleDnsCacheTestDouble(localClock);
            var cacheEntry = Dns.Resolved.Create("test.local", System.Net.Dns.GetHostEntry("127.0.0.1").AddressList);
            cache.Put(cacheEntry, 5000);

            cache.Cached("test.local").ShouldBe(cacheEntry);
            localClock.CompareAndSet(0, 4999);
            cache.Cached("test.local").ShouldBe(cacheEntry);
            localClock.CompareAndSet(4999, 5000);
            cache.Cached("test.local").ShouldBe(null);

        }

        internal ConnectionState(ZookeeperFactory zookeeperFactory, EnsembleProvider ensembleProvider,
            int sessionTimeoutMs, int connectionTimeoutMs, Watcher parentWatcher, AtomicReference<TracerDriver> tracer,
            bool canBeReadOnly)
        {
            this.ensembleProvider = ensembleProvider;
            this.sessionTimeoutMs = sessionTimeoutMs;
            this.connectionTimeoutMs = connectionTimeoutMs;
            this.tracer = tracer;
            if (parentWatcher != null)
            {
                parentWatchers.AddLast(parentWatcher);
            }

            zooKeeper = new HandleHolder(zookeeperFactory, this, ensembleProvider, sessionTimeoutMs, canBeReadOnly);
        }