public void LabelExpansionWithDotPrefixAndEmptyKeys()
 {
     var template = new UriTemplate("X{.empty_keys}");
     template.SetParameter("empty_keys", new Dictionary<string, string>());
     var uriString = template.Resolve();
     Assert.Equal("X", uriString);
 }

        public void ExtendedSamplesTest(string template, string[] results, TestSet.TestCase testCase)
        {
            var uriTemplate = new UriTemplate(template);

            foreach (var variable in testCase.TestSet.Variables)
            {
                uriTemplate.SetParameter(variable.Key, variable.Value);
            }

            string result = null;
            ArgumentException aex = null;

            try
            {
                result = uriTemplate.Resolve();

            }
            catch (ArgumentException ex)
            {
                aex = ex;
            }

            if (results[0] == "False")
            {
                Assert.NotNull(aex);
            }
            else
            {
                Assert.True(results.Contains(result));
            }

        }

        // Disabled for the moment. [Theory, PropertyData("FailureSamples")]
        public void FailureSamplesTest(string template, string[] results, TestSet.TestCase testCase)
        {
            var uriTemplate = new UriTemplate(template);

            foreach (var variable in testCase.TestSet.Variables)
            {
                uriTemplate.SetParameter(variable.Key, variable.Value);
            }

            string result = null;
            ArgumentException aex = null;

            try
            {
                result = uriTemplate.Resolve();

            }
            catch (ArgumentException ex)
            {
                aex = ex;
            }

            Assert.NotNull(aex);


        }

 public void FactMethodName()
 {
     UriTemplate template = new UriTemplate("https://api.github.com/search/code?q={query}{&page,per_page,sort,order}");
     template.SetParameter("query", "1234");
     template.SetParameter("per_page", "19");
     var result = template.Resolve();
 }

 public void ShouldAllowUriTemplateWithPathSegmentParameter()
 {
     var template = new UriTemplate("http://example.org/foo/{bar}/baz");
     template.SetParameter("bar", "yo");
     var uriString = template.Resolve();
     Assert.Equal("http://example.org/foo/yo/baz", uriString);
 }

        public void QueryParametersTheNewWay()
        {
            var url = new UriTemplate("http://example.org/customers{?active}")
                .AddParameter("active", "true")
                .Resolve();

            Assert.Equal("http://example.org/customers?active=true", url);
        }

        public void UpdatePathParameter()
        {
            var url = new UriTemplate("http://example.org/{tenant}/customers")
                .AddParameter("tenant", "acmé")
                .Resolve();

            Assert.Equal("http://example.org/acm%C3%A9/customers", url);
        }

        public void ShouldResolveUriTemplateWithNonStringParameter()
        {
            var url = new UriTemplate("http://example.org/location{?lat,lng}")
                .AddParameters(new { lat = 31.464, lng = 74.386 })
                .Resolve();

            Assert.Equal("http://example.org/location?lat=31.464&lng=74.386", url);
        }

        public void SpecTest(TestCase testCase)
        {
            Assume.That(!testCase.IsInvalid);

            var uriTemplate = new UriTemplate(testCase.Template);
            var uri = uriTemplate.Resolve(testCase.Suite.Variables);
            Assert.Contains(uri, testCase.Expecteds);
        }

        private static Uri ResolveDocumentationUri(ILinkObject link, string rel)
        {
            var template = new UriTemplate(link.Href.ToString());

            template.SetParameter("rel", rel);

            return new Uri(template.Resolve());
        }

 public void ShouldAllowUriTemplateWithQueryParamsButNoValues()
 {
     var template = new UriTemplate("http://example.org/foo{?bar,baz}");
     //template.SetParameter("bar", "yo");
     //template.SetParameter("blar", "yuck");
     var uriString = template.Resolve();
     Assert.Equal("http://example.org/foo", uriString);
 }

        public void ShouldAllowUriTemplateWithQueryParamsWithOneValue()
        {
            var template = new UriTemplate("http://example.org/foo{?bar,baz}");
            template.SetParameter("baz", "yo");

            var uriString = template.Resolve();
            Assert.Equal("http://example.org/foo?baz=yo", uriString);
        }

        private static string ResolveTemplateUrl(string href, Dictionary<string, string> values)
        {
            var template = new UriTemplate(href);

            foreach (var templateValue in values)
                template.SetParameter(templateValue.Key, templateValue.Value);

            return template.Resolve();
        }

        public UriTemplateBuilder(UriTemplate uriTemplate)
        {
            if (uriTemplate == null)
            {
                throw new ArgumentNullException("uriTemplate");
            }

            this.components = new List<IUriTemplateComponent>(uriTemplate.Components);
        }

 public void ShouldAllowListAndSingleValueInQueryParam()
 {
     var template = new UriTemplate("http://example.org{/id*}{?fields,token}");
     template.SetParameter("id", new List<string>() { "person", "albums" });
     template.SetParameter("fields", new List<string>() { "id", "name", "picture" });
     template.SetParameter("token", "12345");
     var uriString = template.Resolve();
     Assert.Equal("http://example.org/person/albums?fields=id,name,picture&token=12345", uriString);
 }

        public void QueryParametersTheNewWayWithoutValue()
        {

            var url = new UriTemplate("http://example.org/customers{?active}")
                .AddParameters(null)
                .Resolve();

            Assert.Equal("http://example.org/customers", url);
        }

        public void ShouldAllowUriTemplateToRemoveParameter()
        {
            var template = new UriTemplate("http://example.org/foo{?bar,baz}");
            template.SetParameter("bar", "yo");
            template.SetParameter("baz", "yuck");
            template.ClearParameter("bar");

            var uriString = template.Resolve();
            Assert.Equal("http://example.org/foo?baz=yuck", uriString);
        }

        public void Query_param_with_list_array()
        {
            UriTemplate template = new UriTemplate("/foo/{foo}/baz{?haz}");
            template.SetParameter("foo", "1234");
            template.SetParameter("haz", new string[] { "foo", "bar" });

            string uri = template.Resolve();

            Assert.Equal("/foo/1234/baz?haz=foo,bar", uri);
        }

        public static UriTemplate MakeTemplate(this Uri uri, IDictionary<string, object> parameters)
        {
            var target = uri.GetComponents(UriComponents.AbsoluteUri
                                                     & ~UriComponents.Query
                                                     & ~UriComponents.Fragment, UriFormat.Unescaped);
            var template = new UriTemplate(target + "{?" + string.Join(",", parameters.Keys.ToArray()) + "}");
            template.AddParameters(parameters);

            return template;
        }

        public async Task<ContentResponse> GetProfile(string artistId)
        {
            var parameters = new Dictionary<string, string>();
            parameters.Add("apikey", _apikey);
            parameters.Add("artistid", artistId);

            var template = new UriTemplate("artist/profile?api_key={apikey}&id=songkick:artist:{artistid}&bucket=id:spotify&format=json");

            return await GetWithRetryAsync(baseUri, template, parameters);
        }