/// <summary>
    /// Retrieves items from pocket
    /// with the given filters
    /// </summary>
    /// <param name="state">The state.</param>
    /// <param name="favorite">The favorite.</param>
    /// <param name="tag">The tag.</param>
    /// <param name="contentType">Type of the content.</param>
    /// <param name="sort">The sort.</param>
    /// <param name="search">The search.</param>
    /// <param name="domain">The domain.</param>
    /// <param name="since">The since.</param>
    /// <param name="count">The count.</param>
    /// <param name="offset">The offset.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns></returns>
    /// <exception cref="PocketException"></exception>
    public async Task<IEnumerable<PocketItem>> Get(
      State? state = null,
      bool? favorite = null,
      string tag = null,
      ContentType? contentType = null,
      Sort? sort = null,
      string search = null,
      string domain = null,
      DateTime? since = null,
      int? count = null,
      int? offset = null,
      CancellationToken cancellationToken = default(CancellationToken)
    )
    {
      RetrieveParameters parameters = new RetrieveParameters()
      {
        State = state,
        Favorite = favorite,
        Tag = tag,
        ContentType = contentType,
        Sort = sort,
        DetailType = DetailType.complete,
        Search = search,
        Domain = domain,
        Since = since.HasValue ? ((DateTime)since).ToUniversalTime() : since,
        Count = count,
        Offset = offset
      };

      return (await Request<Retrieve>("get", cancellationToken, parameters.Convert())).Items ?? new List<PocketItem>();
    }

        private static void Main(string[] args)
        {
            Sort<string> sort = new Sort<string>();

            string[] array = new string[10]
            {
                "table",
                "coffee",
                "tea",
                "juice",
                "1",
                "apple",
                "sea",
                "tree",
                "leopard",
                "ant",
            };

            Console.WriteLine("Before sorting:");
            sort.Print(array);

            sort.SortArray(array, CompareStrings);

            Console.WriteLine("After sorting:");
            sort.Print(array);
        }

		public Particle (int par1x, int par2y, Color par4color, Sort par5type)
		{
			life = 1F;
			int side = rand.Next (3, 5);
			if (par5type == Sort.Fog)
				side = rand.Next (5, 15);
			link = new Vector2 (par1x, par2y);
			if (par5type == Sort.Fixed) {
				int g = rand.Next (1, 3);
				if (g != 1)
					g = -1;
				int h = rand.Next (1, 3);
				if (h != 1)
					h = -1;
				par1x += rand.Next (0, 15) * g;
				par2y += rand.Next (0, 15) * h;
			}
			shape = new Rectangle (par1x, par2y, side, side);
			position = new Vector2 (shape.X, shape.Y);
			color = par4color;
			sprite = new Texture2D (Core.graphicsD, 1, 1);
			sprite.SetData (new Color[]{ color });
			if(par5type != Sort.Fog)
				light = EffectManager.addLight (new Light (shape.X + shape.Width / 2, shape.Y + shape.Height / 2, side / 10F, color));
			else
				life = 0.3F;
			type = par5type;
		}

        public List<User> Search(string request, Sort sort, out int count, int offset = 0,
            SearchProfileFields[] fields = null)
        {
            List<User> users = new List<User>();

            NameValueCollection qs = new NameValueCollection();
            qs["q"] = request;

            if (fields != null)
                qs["fields"] = String.Join(",", from field in fields select field.ToString());

            qs["sort"] = ((int)sort).ToString();
            qs["offset"] = offset.ToString();

            XmlDocument answer = VkResponse.ExecuteCommand("users.search", qs);

            XmlNode node = answer.SelectSingleNode("response/count");
            if (node != null)
                count = Convert.ToInt32(node.InnerText);
            else
            {
                count = 0;
            }

            XmlNodeList usersNodes = answer.SelectNodes("response/user");

            if (usersNodes != null)
                foreach (XmlNode user in usersNodes)
                {
                    users.Add(new User(user));
                }

            return users;
        }

 public static async Task<Response<List<Image>>> GetGallery(Section? section = null, Sort? sort = null, Window? window = null, bool? showViral = null, int? page = null)
 {
     string uri = "gallery";
     if (section != null)
     {
         uri += "/" + section.ToString().ToLower();
         if(sort != null)
         {
             uri += "/" + sort.ToString().ToLower();
             if(window != null)
             {
                 uri += "/" + window.ToString().ToLower();
                 if (showViral != null)
                 {
                     uri += "/" + showViral.ToString();
                     if (page != null)
                     {
                         uri += "/" + page;
                     }
                 }
             }
         }
     }
     return await NetworkHelper.GetRequest<List<Image>>(uri);
 }

        /// <summary>Gets events.</summary>
        /// <param name="pagination">Pagination.</param>
        /// <param name="filter">Filters for events.</param>
        /// <param name="sort">Sort.</param>
        /// <returns>List of events matching passed filter criteria.</returns>
        public ListPaginated<EventDTO> GetAll(Pagination pagination, FilterEvents filter = null, Sort sort = null)
        {
            if (filter == null)
                return this.GetList<EventDTO>(MethodKey.EventsAll, pagination, "");

            return this.GetList<EventDTO>(MethodKey.EventsAll, pagination, "", sort, filter.GetValues());
        }

 public void WithNullParameters_ThrowsException()
 {
     Sort sort = new Sort();
     var ex = Assert.Throws<ArgumentNullException>(
         () => Generator.Object.Select(ClassMap.Object, null, null, null));
     StringAssert.Contains("cannot be null", ex.Message);
     Assert.AreEqual("Parameters", ex.ParamName);
 }

        //
        // GET: /Advertisements/

        public ActionResult List(Sort sort = Sort.PublishDate, uint minPrice = 0, uint maxPrice = Int32.MaxValue)
        {
            log.Debug("Run List()");

            var advertisements = repository.Advertisements.Where(adv => minPrice <= adv.Price && adv.Price <= maxPrice).OrderBy(sort);
            var advertisementsListPagemodel = new AdvertisementsListPage(advertisements, sort, new AdvertisementsFilter(minPrice, maxPrice));
            return View(advertisementsListPagemodel);
        }

 public ActionResult GetItems(Sort v)
 {
     var options = new[]
                       {
                           new SelectableItem(Sort.None, "None", v == Sort.None),
                           new SelectableItem(Sort.Asc, "Asc", v== Sort.Asc),
                           new SelectableItem(Sort.Desc, "Desc", v== Sort.Desc)
                       };
     return Json(options);
 }

 public PersonnageJouable(int id, string nom, int lvl, int exp, EnumTypePersonnage tp, Equipement eq, CaracteristiquesPersonnage cp, ArbreCompetence ac)
 {
     _id = id;
     _nom = nom;
     _lvl = lvl;
     _exp = exp;
     _sort = new Sort[20];
     _typePersonnage = tp;
     _equipement = eq;
     _CPersonnage = cp;
     _ACompetence = ac;
 }

        public void BubbleSortSlowest_Fail_EmptyArray()
        {
            // ARRANGE
            Sort sortAlgos = new Sort();
            int[] testNums = { };

            // ACT
            sortAlgos.BubbleSlowest(testNums);

            // ASSERT
            // ExpectedException attribute
        }

 public Ennemi(int id, string nom, int lvl, int exp, EnumTypePersonnage tp, Equipement eq, CaracteristiquesPersonnage cp, EnumStatusEnnemi st, Ia ia)
 {
     _id = id;
     _nom = nom;
     _lvl = lvl;
     _exp = exp;
     _sort = new Sort[20];
     _typePersonnage = tp;
     _equipement = eq;
     _CPersonnage = cp;
     _status = st;
     _ia = ia;
 }

 public static async Task<Response<List<Image>>> GetTopicGallery(int topicId, Sort? sort = null, int? page = null)
 {
     //{topicId}/{sort}/{page}
     string uri = "topics/" + topicId;
     if (sort != null)
     {
         if (page != null)
         {
             uri += "/" + page;
         }
     }
     return await NetworkHelper.GetRequest<List<Image>>(uri);
 }

 public static IEnumerable<Advertisement> OrderBy(this IEnumerable<Advertisement> advertisements, Sort sort)
 {
     switch (sort)
     {
         case Sort.Name:
             return advertisements.OrderBy(adv => adv.Name);
         case Sort.Price:
             return advertisements.OrderBy(adv => adv.Price);
         case Sort.PublishDate:
         default:
             return advertisements.OrderBy(adv => adv.PublishDate);
     }
 }

        public void BubbleSortSlower_Success_Descending()
        {
            // ARRANGE
            Sort sortAlgos = new Sort(SortOrder.Desc);

            // ACT
            int[] result = sortAlgos.BubbleSlower(testNumsUnordered);

            // ASSERT
            for (int i = 0; i < result.Length; i++)
            {
                Assert.AreEqual(testNumsOrderedDesc[i], result[i]);
            }
        }

        public void BubbleSortSlowest_Success()
        {
            // ARRANGE
            Sort sortAlgos = new Sort();

            // ACT
            int[] result = sortAlgos.BubbleSlowest(testNumsUnordered);

            // ASSERT
            for (int i = 0; i < result.Length; i++)
            {
                Assert.AreEqual(testNumsOrderedAsc[i], result[i]);
            }
        }

 /*
     Simple Bubble sort using pointer to function for chosing to sort
     by SSN ascending
 */
 public static void BubbleSort(IPayable[] employees, Sort sort)
 {
     for(int i = employees.Length; i > 0; i--)
     {
         for (int j = 1; j < i; j++)
         {
             IPayable temp = employees[j - 1];
             //use pointer to function
             if((sort(employees[j], employees[j - 1]) < 1)){
                 //swap
                 employees[j - 1] = employees[j];
                 employees[j] = temp;
             }//end if
         }//end for
     }//end for
 }

        public static async Task<Response<List<Image>>> GetSubreddditGallery(string subreddit, Sort? sort = null, Window? window = null, int? page = null)
        {
            //{ subreddit}/{ sort}/{ window}/{ page}
            string uri = "gallery/r/" + subreddit;
            if (sort != null)
            {
                uri += "/" + sort.ToString().ToLower();
                if (window != null)
                {
                    uri += "/" + window.ToString().ToLower();

                    if (page != null)
                    {
                        uri += "/" + page;
                    }
                }
            }
            return await NetworkHelper.GetRequest<List<Image>>(uri);
        }

        public void Objects()
        {
            string str;
            object nested = new Outer.Nested<int>();

            str = CSharpObjectFormatter.Instance.FormatObject(nested, s_inline);
            Assert.Equal(@"Outer.Nested<int> { A=1, B=2 }", str);

            str = CSharpObjectFormatter.Instance.FormatObject(nested, new ObjectFormattingOptions(memberFormat: MemberDisplayFormat.NoMembers));
            Assert.Equal(@"Outer.Nested<int>", str);

            str = CSharpObjectFormatter.Instance.FormatObject(A<int>.X, new ObjectFormattingOptions(memberFormat: MemberDisplayFormat.NoMembers));
            Assert.Equal(@"A<int>.B<int>", str);

            object obj = new A<int>.B<bool>.C.D<string, double>.E();
            str = CSharpObjectFormatter.Instance.FormatObject(obj, new ObjectFormattingOptions(memberFormat: MemberDisplayFormat.NoMembers));
            Assert.Equal(@"A<int>.B<bool>.C.D<string, double>.E", str);

            var sort = new Sort();
            str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 51, memberFormat: MemberDisplayFormat.Inline));
            Assert.Equal(@"Sort { aB=-1, ab=1, Ac=-1, Ad=1, ad=-1, aE=1, a ...", str);
            Assert.Equal(51, str.Length);

            str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 5, memberFormat: MemberDisplayFormat.Inline));
            Assert.Equal(@"S ...", str);
            Assert.Equal(5, str.Length);

            str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 4, memberFormat: MemberDisplayFormat.Inline));
            Assert.Equal(@"...", str);

            str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 3, memberFormat: MemberDisplayFormat.Inline));
            Assert.Equal(@"...", str);

            str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 2, memberFormat: MemberDisplayFormat.Inline));
            Assert.Equal(@"...", str);

            str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 1, memberFormat: MemberDisplayFormat.Inline));
            Assert.Equal(@"...", str);

            str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 80, memberFormat: MemberDisplayFormat.Inline));
            Assert.Equal(@"Sort { aB=-1, ab=1, Ac=-1, Ad=1, ad=-1, aE=1, aF=-1, AG=1 }", str);
        }

 public void Run()
 {
     using (Context ctx = new Context()) {
         Symbol s1 = ctx.MkSymbol(1);
         Symbol s2 = ctx.MkSymbol(1);
         Symbol s3 = ctx.MkSymbol(2);
         Sort[] domain = new Sort[0];
     Sort range = ctx.IntSort;
         TestDriver.CheckAssertion("a1", s1 == s2);
         TestDriver.CheckAssertion("a2", s1 != s3);
         TestDriver.CheckAssertion("a3", ctx.MkSymbol("x") != s1);
         TestDriver.CheckAssertion("a4", ctx.MkSymbol("x") == ctx.MkSymbol("x"));
         TestDriver.CheckAssertion("a5", ctx.MkFuncDecl("f", domain, range) == ctx.MkFuncDecl("f", domain, range));
         TestDriver.CheckAssertion("a6", ctx.MkFuncDecl("f", domain, range) != ctx.MkFuncDecl("g", domain, range));
         TestDriver.CheckAssertion("a7", ctx.MkUninterpretedSort("s") == ctx.MkUninterpretedSort("s"));
         TestDriver.CheckAssertion("a8", ctx.MkUninterpretedSort("s") != ctx.MkUninterpretedSort("t"));
         TestDriver.CheckAssertion("a9", ctx.MkUninterpretedSort("s") != ctx.IntSort);
         TestDriver.CheckAssertion("a10", ctx.MkConst("x", range) == ctx.MkConst("x", range));
         TestDriver.CheckAssertion("a11", ctx.MkConst("x", range) == ctx.MkConst(ctx.MkSymbol("x"), range));
         TestDriver.CheckAssertion("a12", ctx.MkConst("x", range) != ctx.MkConst("y", range));
     }
 }