/// <summary>
        /// Implements the ListRanges method.
        /// </summary>
        /// <param name="accessCondition">An object that represents the access conditions for the file. If null, no condition is used.</param>
        /// <param name="options">An object that specifies additional options for the request.</param>
        /// <returns>A <see cref="RESTCommand"/> for getting the ranges.</returns>
        private RESTCommand<IEnumerable<FileRange>> ListRangesImpl(long? offset, long? length, AccessCondition accessCondition, FileRequestOptions options)
        {
            RESTCommand<IEnumerable<FileRange>> getCmd = new RESTCommand<IEnumerable<FileRange>>(this.ServiceClient.Credentials, this.StorageUri);

            options.ApplyToStorageCommand(getCmd);
            getCmd.CommandLocationMode = CommandLocationMode.PrimaryOrSecondary;
            getCmd.RetrieveResponseStream = true;
            getCmd.Handler = this.ServiceClient.AuthenticationHandler;
            getCmd.BuildClient = HttpClientFactory.BuildHttpClient;
            getCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) =>
            {
                HttpRequestMessage msg = FileHttpRequestMessageFactory.ListRanges(uri, serverTimeout, offset, length, accessCondition, cnt, ctx);
                FileHttpRequestMessageFactory.AddMetadata(msg, this.Metadata);
                return msg;
            };

            getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
            getCmd.PostProcessResponse = (cmd, resp, ctx) =>
            {
                this.UpdateETagLMTAndLength(resp, true);
                return Task.Factory.StartNew(() =>
                {
                    ListRangesResponse listRangesResponse = new ListRangesResponse(cmd.ResponseStream);
                    IEnumerable<FileRange> ranges = listRangesResponse.Ranges.ToList();
                    return ranges;
                });
            };

            return getCmd;
        }
        /// <summary>
        /// Gets the ranges implementation.
        /// </summary>
        /// <param name="offset">The start offset.</param>
        /// <param name="length">Length of the data range to be cleared.</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the file. If <c>null</c>, no condition is used.</param>
        /// <param name="options">An <see cref="FileRequestOptions"/> object that specifies additional options for the request.</param>
        /// <returns>A <see cref="RESTCommand{T}"/> for getting the ranges.</returns>
        private RESTCommand<IEnumerable<FileRange>> ListRangesImpl(long? offset, long? length, AccessCondition accessCondition, FileRequestOptions options)
        {
            RESTCommand<IEnumerable<FileRange>> getCmd = new RESTCommand<IEnumerable<FileRange>>(this.ServiceClient.Credentials, this.StorageUri);

            options.ApplyToStorageCommand(getCmd);
            getCmd.CommandLocationMode = CommandLocationMode.PrimaryOrSecondary;
            getCmd.RetrieveResponseStream = true;
            getCmd.BuildRequestDelegate = (uri, builder, serverTimeout, useVersionHeader, ctx) => FileHttpWebRequestFactory.ListRanges(uri, serverTimeout, offset, length, accessCondition, useVersionHeader, ctx);
            getCmd.SetHeaders = (r, ctx) => FileHttpWebRequestFactory.AddMetadata(r, this.Metadata);
            getCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
            getCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp, null /* retVal */, cmd, ex);
            getCmd.PostProcessResponse = (cmd, resp, ctx) =>
            {
                this.UpdateETagLMTAndLength(resp, true);
                ListRangesResponse listRangesResponse = new ListRangesResponse(cmd.ResponseStream);
                IEnumerable<FileRange> ranges = listRangesResponse.Ranges.ToList();
                return ranges;
            };

            return getCmd;
        }
        public void ClearRangeScenarioTest(string shareName, string fileName, HttpStatusCode? expectedError)
        {
            // 1. Create Sparse File
            int fileSize = 128 * 1024;

            FileProperties properties = new FileProperties();
            Uri uri = FileTests.ConstructPutUri(FileContext.Address, shareName, fileName);
            OperationContext opContext = new OperationContext();
            HttpWebRequest webRequest = FileHttpWebRequestFactory.Create(uri, FileContext.Timeout, properties, fileSize, null, true, opContext);

            FileTests.SignRequest(webRequest, FileContext);

            using (HttpWebResponse response = webRequest.GetResponse() as HttpWebResponse)
            {
                FileTests.PutFileResponse(response, FileContext, expectedError);
            }

            // 2. Now upload some ranges
            for (int m = 0; m * 512 * 4 < fileSize; m++)
            {
                int startOffset = 512 * 4 * m;
                int length = 512;

                FileRange range = new FileRange(startOffset, startOffset + length - 1);
                opContext = new OperationContext();
                HttpWebRequest rangeRequest = FileHttpWebRequestFactory.PutRange(uri, FileContext.Timeout, range, FileRangeWrite.Update, null, true, opContext);
                rangeRequest.ContentLength = 512;
                FileTests.SignRequest(rangeRequest, FileContext);

                Stream outStream = rangeRequest.GetRequestStream();

                for (int n = 0; n < 512; n++)
                {
                    outStream.WriteByte((byte)m);
                }

                outStream.Close();
                using (HttpWebResponse rangeResponse = rangeRequest.GetResponse() as HttpWebResponse)
                {
                }
            }

            // 3. Now do a List Ranges
            List<FileRange> fileRanges = new List<FileRange>();
            opContext = new OperationContext();
            HttpWebRequest listRangesRequest = FileHttpWebRequestFactory.ListRanges(uri, FileContext.Timeout, null, null, null, true, opContext);
            FileTests.SignRequest(listRangesRequest, FileContext);
            using (HttpWebResponse rangeResponse = listRangesRequest.GetResponse() as HttpWebResponse)
            {
                ListRangesResponse listRangesResponse = new ListRangesResponse(rangeResponse.GetResponseStream());
                fileRanges.AddRange(listRangesResponse.Ranges.ToList());
            }

            // 4. Now Clear some ranges
            bool skipFlag = false;
            foreach (FileRange pRange in fileRanges)
            {
                skipFlag = !skipFlag;
                if (skipFlag)
                {
                    continue;
                }

                opContext = new OperationContext();
                HttpWebRequest clearRangeRequest = FileHttpWebRequestFactory.PutRange(uri, FileContext.Timeout, pRange, FileRangeWrite.Clear, null, true, opContext);
                clearRangeRequest.ContentLength = 0;
                FileTests.SignRequest(clearRangeRequest, FileContext);
                using (HttpWebResponse clearResponse = clearRangeRequest.GetResponse() as HttpWebResponse)
                {
                }
            }

            // 5. Get New ranges and verify
            List<FileRange> newFileRanges = new List<FileRange>();

            opContext = new OperationContext();
            HttpWebRequest newFileRangeRequest = FileHttpWebRequestFactory.ListRanges(uri, FileContext.Timeout, null, null, null, true, opContext);
            FileTests.SignRequest(newFileRangeRequest, FileContext);
            using (HttpWebResponse newFileRangeResponse = newFileRangeRequest.GetResponse() as HttpWebResponse)
            {
                ListRangesResponse listNewRangesResponse = new ListRangesResponse(newFileRangeResponse.GetResponseStream());
                newFileRanges.AddRange(listNewRangesResponse.Ranges.ToList());
            }

            Assert.AreEqual(fileRanges.Count(), newFileRanges.Count() * 2);
            for (int l = 0; l < newFileRanges.Count(); l++)
            {
                Assert.AreEqual(fileRanges[2 * l].StartOffset, newFileRanges[l].StartOffset);
                Assert.AreEqual(fileRanges[2 * l].EndOffset, newFileRanges[l].EndOffset);
            }
        }