Exemplo n.º 1
0
		public void SerializeObject ()
		{
			Poker p = new Poker ();
			DateTime dt = new DateTime (2005, 9, 25, 22, 30, 45);
			string s = p.Serialize (dt);
			Assert.AreEqual ("new Date(2005,8,25,22,30,45)", s, "A1");
		}
		public void Properties ()
		{
			Poker p = new Poker ("name", "value");
			ConfigurationPropertyCollection props = p.GetProperties();

			Assert.IsNotNull (props, "A1");
			Assert.AreEqual (2, props.Count, "A2");

			ConfigurationProperty prop;

			prop = props["key"];
			Assert.AreEqual ("key", prop.Name, "A3");
			Assert.IsNull   (prop.Description, "A4");
			Assert.AreEqual (typeof (string), prop.Type, "A5");
			Assert.AreEqual (typeof (StringConverter), prop.Converter.GetType(), "A6");
			Assert.IsNotNull (prop.Validator, "Anull");
			Assert.AreEqual (typeof (DefaultValidator), prop.Validator.GetType(), "A7");
			Assert.AreEqual ("", prop.DefaultValue, "A8");
			Assert.IsTrue   (prop.IsKey, "A9");
			Assert.IsTrue   (prop.IsRequired, "A10");

			Assert.IsFalse  (prop.IsDefaultCollection, "A11");

			prop = props["value"];
			Assert.AreEqual ("value", prop.Name, "A12");
			Assert.IsNull   (prop.Description, "A13");
			Assert.AreEqual (typeof (string), prop.Type, "A14");
			Assert.AreEqual (typeof (StringConverter), prop.Converter.GetType(), "A15");
			Assert.AreEqual (typeof (DefaultValidator), prop.Validator.GetType(), "A16");
			Assert.AreEqual ("", prop.DefaultValue, "A17");
			Assert.IsFalse  (prop.IsKey, "A18");
			Assert.IsFalse  (prop.IsRequired, "A19");

			Assert.IsFalse  (prop.IsDefaultCollection, "A20");
		}
		public void SerializeObject ()
		{
			Poker p = new Poker ();
			string s = p.Serialize ("hi");

			Assert.IsNull (s, "A1");
		}
Exemplo n.º 4
0
	public void ControlsAccessorTest ()
  	{
		Poker p = new Poker();

		ControlCollection col = p.Controls;

		Assert.AreEqual (col.Count, 1, "Controls accessor causes child control creation.");
	}
		public void SupportedTypes ()
		{
			Poker p = new Poker ();

			Type[] ts = p.GetSupportedTypes();

			Assert.IsNull (ts, "A1");
		}
		public void Add ()
		{
			Poker p = new Poker();

			Assert.AreEqual (0, p.Count, "A1");

			p.Add (new PokerElement ("hi"));
		}
Exemplo n.º 7
0
		public void Properties () {

			Poker p1 = new Poker ();
			Poker p2 = new Poker ();

			Assert.AreEqual (false, p1.GetProperties ().Contains ("myProperty"), "Contains myProperty");
			Assert.AreEqual (false, p1.GetProperties () == p2.GetProperties (), "#");
		}
Exemplo n.º 8
0
		public void SupportedTypes ()
		{
			Poker p = new Poker ();

			Type[] ts = p.GetSupportedTypes();

			Assert.AreEqual (1, ts.Length, "A1");
			Assert.AreEqual (typeof (DateTime), ts[0], "A2");
		}
Exemplo n.º 9
0
		public void TestUseDefaultCredentials () {
			Poker client = new Poker ();
			Assert.IsFalse (client.UseDefaultCredentials, "#1");
			client.UseDefaultCredentials = true;
			Assert.IsTrue (client.Credentials == CredentialCache.DefaultCredentials, "#2");
			client.Credentials = new NetworkCredential ("a", "b");
			Assert.IsFalse (client.UseDefaultCredentials, "#3");
			client.UseDefaultCredentials = false;
			Assert.IsNull (client.Credentials, "#4");
			client.Credentials = CredentialCache.DefaultCredentials;
			Assert.IsTrue (client.UseDefaultCredentials, "#5");
		}
Exemplo n.º 10
0
        public void IsFlushTest_True()
        {
            var pokerHand = new List <Card>()
            {
                new Card(Rank.Ace, Suit.Diamonds),
                new Card(Rank.Two, Suit.Diamonds),
                new Card(Rank.Nine, Suit.Diamonds),
                new Card(Rank.Ten, Suit.Diamonds),
                new Card(Rank.Seven, Suit.Diamonds),
            };

            Assert.True(Poker.IsFlush(pokerHand));
        }
Exemplo n.º 11
0
        public void IsStraightTest_True()
        {
            var pokerHand = new List <Card>()
            {
                new Card(Rank.Two, Suit.Diamonds),
                new Card(Rank.Three, Suit.Spades),
                new Card(Rank.Four, Suit.Diamonds),
                new Card(Rank.Five, Suit.Diamonds),
                new Card(Rank.Six, Suit.Diamonds),
            };

            Assert.True(Poker.IsStraight(pokerHand));
        }
Exemplo n.º 12
0
        [ExpectedException(typeof(NullReferenceException))]           // this happens with MS anyway.
        public void Attributes()
        {
            Poker            c = new Poker();
            StringWriter     sw;
            ScriptTextWriter w;

            sw = new StringWriter();
            w  = new ScriptTextWriter(sw);

            c.AddAttributes(w);

            Assert.AreEqual("", sw.ToString(), "A1");
        }
Exemplo n.º 13
0
        public void TestFourOfAkind()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Spade, Rank.four),
                new Card(Suit.Heart, Rank.four),
                new Card(Suit.Spade, Rank.five),
                new Card(Suit.Dimond, Rank.four),
                new Card(Suit.Club, Rank.four)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("FOUROFAKIND", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 14
0
        public void TestStraight()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Heart, Rank.two),
                new Card(Suit.Dimond, Rank.three),
                new Card(Suit.Club, Rank.four),
                new Card(Suit.Heart, Rank.five),
                new Card(Suit.Spade, Rank.six)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("STRAIGHT", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 15
0
        public void TestThreeOfAKind()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Heart, Rank.two),
                new Card(Suit.Dimond, Rank.two),
                new Card(Suit.Club, Rank.two),
                new Card(Suit.Heart, Rank.ace),
                new Card(Suit.Spade, Rank.queen)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("THREEOFAKIND", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 16
0
        public void IsTwoPairTest_True()
        {
            var pokerHand = new List <Card>()
            {
                new Card(Rank.Ace, Suit.Diamonds),
                new Card(Rank.Ace, Suit.Spades),
                new Card(Rank.Nine, Suit.Diamonds),
                new Card(Rank.Nine, Suit.Spades),
                new Card(Rank.Seven, Suit.Diamonds),
            };

            Assert.True(Poker.IsTwoPair(pokerHand));
        }
Exemplo n.º 17
0
        public void IsFullHouseTest_True()
        {
            var pokerHand = new List <Card>()
            {
                new Card(Rank.Ace, Suit.Diamonds),
                new Card(Rank.Ace, Suit.Spades),
                new Card(Rank.Nine, Suit.Diamonds),
                new Card(Rank.Nine, Suit.Clubs),
                new Card(Rank.Nine, Suit.Spades),
            };

            Assert.True(Poker.IsFullHouse(pokerHand));
        }
Exemplo n.º 18
0
        public void IsStraightFlushTest_True()
        {
            var pokerHand = new List <Card>()
            {
                new Card(Rank.Five, Suit.Diamonds),
                new Card(Rank.Six, Suit.Diamonds),
                new Card(Rank.Seven, Suit.Diamonds),
                new Card(Rank.Eight, Suit.Diamonds),
                new Card(Rank.Nine, Suit.Diamonds),
            };

            Assert.True(Poker.IsStraightFlush(pokerHand));
        }
Exemplo n.º 19
0
        public void TestHighCard()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Heart, Rank.seven),
                new Card(Suit.Dimond, Rank.two),
                new Card(Suit.Club, Rank.four),
                new Card(Suit.Heart, Rank.ace),
                new Card(Suit.Spade, Rank.jack)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("HIGHCARD", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 20
0
        public void TestTwoPair()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Heart, Rank.two),
                new Card(Suit.Dimond, Rank.two),
                new Card(Suit.Club, Rank.four),
                new Card(Suit.Heart, Rank.five),
                new Card(Suit.Spade, Rank.five)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("TWOPAIR", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 21
0
        public void TestStarightFlush()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Spade, Rank.three),
                new Card(Suit.Spade, Rank.four),
                new Card(Suit.Spade, Rank.five),
                new Card(Suit.Spade, Rank.six),
                new Card(Suit.Spade, Rank.seven)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("STRAIGHTFLUSH", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 22
0
        public void AddStyleAttribute3()
        {
            sw         = new StringWriter();
            sw.NewLine = "\n";             // Keep sanity.
            Poker w1 = new Poker(sw);

            w1.AddStyleAttribute("mystyle", "my value&space");
            w1.RenderBeginTag("div");
            w1.RenderEndTag();
            Assert.AreEqual("my value&space", w1.StyleValue_At_AddStyleAttribute, "StyleValue_At_AddStyleAttribute");
            Assert.AreEqual("my value&amp;space", w1.StyleValue_At_OnStyleAttributeRender, "StyleValue_At_OnStyleAttributeRender");
            Assert.AreEqual("<div style=\"mystyle:my value&amp;space;\">\n\n</div>", sw.ToString());
        }
Exemplo n.º 23
0
        public void IsRoyalFlushTest_True()
        {
            var pokerHand = new List <Card>()
            {
                new Card(Rank.Ten, Suit.Diamonds),
                new Card(Rank.Jack, Suit.Diamonds),
                new Card(Rank.Queen, Suit.Diamonds),
                new Card(Rank.King, Suit.Diamonds),
                new Card(Rank.Ace, Suit.Diamonds),
            };

            Assert.True(Poker.IsRoyalFlush(pokerHand));
        }
Exemplo n.º 24
0
        public void SupportsDisabledAttribute()
        {
            var ver40 = new Version(4, 0);
            var ver35 = new Version(3, 5);
            var p     = new Poker();

            Assert.AreEqual(ver40, p.RenderingCompatibility, "#A1-1");
            Assert.IsFalse(p.SupportsDisabledAttribute, "#A1-2");

            p.RenderingCompatibility = new Version(3, 5);
            Assert.AreEqual(ver35, p.RenderingCompatibility, "#A2-1");
            Assert.IsTrue(p.SupportsDisabledAttribute, "#A2-2");
        }
Exemplo n.º 25
0
        public void IsThreeOfAKindTest_True()
        {
            var pokerHand = new List <Card>()
            {
                new Card(Rank.Ace, Suit.Diamonds),
                new Card(Rank.Ace, Suit.Spades),
                new Card(Rank.Ace, Suit.Clubs),
                new Card(Rank.Ten, Suit.Diamonds),
                new Card(Rank.Seven, Suit.Diamonds),
            };

            Assert.True(Poker.IsThreeOfAKind(pokerHand));
        }
Exemplo n.º 26
0
    public Sprite GetPokerColorSprite(Poker poker)
    {
        int index = (int)poker.Color;

        if (index >= 0 && index <= 3)
        {
            return(pokerColorSpriteList[index]);
        }
        else
        {
            return(null);
        }
    }
Exemplo n.º 27
0
        public void IsFourOfAKindTest_True()
        {
            var pokerHand = new List <Card>()
            {
                new Card(Rank.Ace, Suit.Diamonds),
                new Card(Rank.Nine, Suit.Hearts),
                new Card(Rank.Nine, Suit.Diamonds),
                new Card(Rank.Nine, Suit.Clubs),
                new Card(Rank.Nine, Suit.Spades),
            };

            Assert.True(Poker.IsFourOfAKind(pokerHand));
        }
Exemplo n.º 28
0
    public Sprite GetPokerNumberSprite(Poker poker)
    {
        int index = (int)(poker.Number);

        if (index >= 1 && index <= 13)
        {
            return(pokerNumberSpriteList[index]);
        }
        else
        {
            return(null);
        }
    }
        public void NoWrap()
        {
            Poker p = new Poker();

            p.Wrap = false;
            p.Controls.Add(new LiteralControl("TEXT"));
#if NET_2_0
            const string html = "<div style=\"white-space:nowrap;\">\n\tTEXT\n</div>";
#elif NET_1_1
            const string html = "<div nowrap=\"nowrap\">\n\tTEXT\n</div>";
#endif
            Assert.AreEqual(html, p.Render());
        }
Exemplo n.º 30
0
        public static void GetPostBackOptions_Load(Page p)
        {
            Poker b = new Poker();

            p.Controls.Add(b);
            b.PostBackUrl = "~/MyPostBackUrl.aspx";
            b.Text        = "MyText";
            PostBackOptions opt = b.GetPostBackOptions();

            Assert.IsNotNull(opt, "PostBackOptions not created");
            Assert.AreEqual("MyPostBackUrl.aspx", opt.ActionUrl, "ActionUrl");
            Assert.AreEqual(b, opt.TargetControl, "TargetControl");
        }
Exemplo n.º 31
0
 void SetPokers(ref List <Poker> pokers)
 {
     for (int i = 1; i <= 13; i++)
     {
         for (int j = 0; j < 4; j++)
         {
             Poker card = new Poker(j, i);
             pokers.Add(card);
         }
     }
     pokers.Add(new Poker(Poker.Variety.王, 1));
     pokers.Add(new Poker(Poker.Variety.王, 2));
 }
Exemplo n.º 32
0
        public void TestRoyalFlush()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Spade, Rank.ten),
                new Card(Suit.Spade, Rank.king),
                new Card(Suit.Spade, Rank.queen),
                new Card(Suit.Spade, Rank.jack),
                new Card(Suit.Spade, Rank.ace)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("ROYALFLUSH", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 33
0
        public void ConfiguredBindings()
        {
            Poker poker = new Poker();

            Assert.AreEqual(0, poker.ConfiguredBindings.Count, "Count #1");

            BasicHttpBindingElement elem = new BasicHttpBindingElement("my_binding");

            poker.Bindings.Add(elem);
            Assert.AreEqual(1, poker.ConfiguredBindings.Count, "Count #2");

            Assert.AreEqual(elem, poker.ConfiguredBindings [0], "Instance");
        }
Exemplo n.º 34
0
        public void TestFlush()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Spade, Rank.ace),
                new Card(Suit.Spade, Rank.four),
                new Card(Suit.Spade, Rank.jack),
                new Card(Suit.Spade, Rank.six),
                new Card(Suit.Spade, Rank.ten)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("FLUSH", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 35
0
        public static void PostBackUrl_Load(Page p)
        {
            Poker b = new Poker();

            p.Controls.Add(b);
            b.PostBackUrl = "~/MyPostBackUrl.aspx";
            string html = b.Render();

            if (html.IndexOf("MyPostBackUrl.aspx") == -1)
            {
                Assert.Fail("PostBackUrl not created");
            }
        }
Exemplo n.º 36
0
        public void TestFullHouse()
        {
            var ownHand = new List <Card> {
                new Card(Suit.Heart, Rank.two),
                new Card(Suit.Dimond, Rank.two),
                new Card(Suit.Club, Rank.two),
                new Card(Suit.Heart, Rank.five),
                new Card(Suit.Spade, Rank.five)
            };
            var myCards = ownHand.OrderBy(x => x.rank).ToList();

            Assert.Equal("FULLHOUSE", Poker.evaluateDeck(myCards));
        }
Exemplo n.º 37
0
        public bool TestRandom()
        {
            Dictionary <string, int> _dict = new Dictionary <string, int>();
            Poker poker     = Poker.Singleton;
            int   randomNum = 0;

            for (int i = 0; i < 54000; i++)
            {
                poker.Shuffle();
                for (int j = 0; j < 6; j++)
                {
                    randomNum++;
                    Card   card = poker.GetCard();
                    string hash = card.ToString();
                    if (!_dict.ContainsKey(hash))
                    {
                        _dict.Add(hash, 0);
                    }
                    _dict[hash] += 1;
                }
            }
            string content = string.Empty;
            int    max     = int.MinValue;
            int    min     = int.MaxValue;

            foreach (string key in _dict.Keys)
            {
                content += string.Format("key:{0} count:{1}\n", key.ToCard(), _dict[key]);
                if (_dict[key] > max)
                {
                    max = _dict[key];
                }
                if (_dict[key] < min)
                {
                    min = _dict[key];
                }
            }
            int range = randomNum / 54 / 10;

            if (_dict.Count != Poker.CARD_NUM)
            {
                Console.WriteLine("生成卡牌数量错误");
                return(false);
            }
            if (max - min > range)
            {
                Console.WriteLine("生成随机数不够随机");
                return(false);
            }
            return(true);
        }
Exemplo n.º 38
0
        public void AddAttributesToRender()
        {
            Poker    p   = new Poker();
            ListItem foo = new ListItem("foo");
            ListItem bar = new ListItem("bar");

            p.Items.Add(foo);
            p.Items.Add(bar);
            #region orig
            string orig = "<select type=\"MyType\" name=\"MyName\" value=\"MyValue\">\n\t<option value=\"foo\">foo</option>\n\t<option value=\"bar\">bar</option>\n\n</select>";
            #endregion
            string html = p.Render();
            HtmlDiff.AssertAreEqual(orig, html, "AddAttributesToRender failed");
        }
Exemplo n.º 39
0
        public void ValidationProperties()
        {
            Poker t = new Poker();

            // initial values
            Assert.AreEqual(false, t.CausesValidation, "A1");
            Assert.AreEqual("", t.ValidationGroup, "A2");

            t.ValidationGroup = "VG";
            Assert.AreEqual("VG", t.ValidationGroup, "A3");

            t.CausesValidation = true;
            Assert.IsTrue(t.CausesValidation, "A4");
        }
Exemplo n.º 40
0
		public void Label_ViewState ()
		{
			XmlPoker p = new XmlPoker ();

			Assert.AreEqual (p.Text, "", "A1");
			p.Text = "Hello";
			Assert.AreEqual (p.Text, "Hello", "A2");

			object state = p.SaveState ();

			Poker copy = new Poker ();
			copy.LoadState (state);
			Assert.AreEqual (copy.Text, "Hello", "A3");
		}
Exemplo n.º 41
0
	public void Defaults ()
  	{
		Poker p = new Poker ();

		Assert.AreEqual (p.AllowClose, true, "A1");
		Assert.AreEqual (p.AllowConnect, true, "A2");
		Assert.AreEqual (p.AllowEdit, true, "A3");
		Assert.AreEqual (p.AllowHide, true, "A4");
		Assert.AreEqual (p.AllowMinimize, true, "A5");
		Assert.AreEqual (p.AllowZoneChange, true, "A6");
		Assert.AreEqual (p.AuthorizationFilter, String.Empty, "A7");
		Assert.AreEqual (p.CatalogIconImageUrl, String.Empty, "A8");
		Assert.AreEqual (p.ChromeState, PartChromeState.Normal, "A9");
		Assert.AreEqual (p.ChromeType, PartChromeType.Default, "A10");
		Assert.AreEqual (p.ConnectErrorMessage, String.Empty, "A11");
		Assert.AreEqual (p.Description, String.Empty, "A12");
		/* Direction - A13 */
		Assert.AreEqual (p.DisplayTitle, "Untitled", "A14");
		Assert.AreEqual (p.ExportMode, WebPartExportMode.None, "A15");
		Assert.AreEqual (p.HasSharedData, false, "A16");
		Assert.AreEqual (p.HasUserData, false, "A17");
		Assert.AreEqual (p.Height, Unit.Empty, "A18");
		Assert.AreEqual (p.HelpMode, WebPartHelpMode.Navigate, "A19");
		Assert.AreEqual (p.HelpUrl, String.Empty, "A20");
		Assert.AreEqual (p.Hidden, false, "A21");
		Assert.AreEqual (p.ImportErrorMessage, "Cannot import this Web Part.", "A22");
		Assert.AreEqual (p.IsClosed, false, "A23");
		Assert.AreEqual (p.IsShared, false, "A24");
		Assert.AreEqual (p.IsStandalone, true, "A25");
		/* this next isn't really a default - it's true
		 * because the part was created programmatically */
		Assert.AreEqual (p.IsStatic, true, "A26"); 
		Assert.AreEqual (p.Subtitle, String.Empty, "A27");
		Assert.AreEqual (p.Title, String.Empty, "A28");
		Assert.AreEqual (p.TitleIconImageUrl, String.Empty, "A29");
		Assert.AreEqual (p.TitleUrl, String.Empty, "A30");
		Assert.IsNotNull (p.Verbs, "A31");
#if IWebEditableInterface
		Assert.AreEqual (p.WebBrowsableObject, null, "A32");
#endif
#if notyet
		Assert.AreEqual (p.WebPartManager, null, "A33");
#endif		
		Assert.AreEqual (p.Width, Unit.Empty, "A34");
		Assert.AreEqual (p.ZoneIndex, 0, "A35");
	}
		public void FormView_DataBind ()
		{
			Poker fv = new Poker ();
			fv.AllowPaging = true;
			fv.DataSource = myds;
			fv.Page = new Page ();
			Assert.AreEqual (0, fv.PageCount, "BeforeDataBind1");
			Assert.AreEqual (null, fv.DataItem, "BeforeDataBind2");
			fv.DataBind ();
			Assert.AreEqual (6, fv.PageCount, "AfterDataBind1");
			Assert.AreEqual (6, fv.DataItemCount, "AfterDataBind2");
			Assert.AreEqual ("Item1", fv.DataItem, "AfterDataBind3");
		}
		public void FormView_DataKey ()
		{
			Page p = new Page ();

			Poker fv = new Poker ();
			p.Controls.Add (fv);

			ObjectDataSource data = new ObjectDataSource ();
			data.TypeName = typeof (FormViewDataObject).AssemblyQualifiedName;
			data.SelectMethod = "Select";
			p.Controls.Add (data);

			fv.DataSource = data;
			fv.DataKeyNames = new string [] { "ID", "FName" };

			DataKey key1 = fv.DataKey;

			Assert.AreEqual (null, key1.Value, "DataKey.Value before binding");
			Assert.AreEqual (0, key1.Values.Count, "DataKey.Values count before binding");

			fv.DataBind ();

			DataKey key2 = fv.DataKey;
			DataKey key3 = fv.DataKey;

			Assert.IsFalse (Object.ReferenceEquals (key1, key2), "DataKey returns the same instans");
			Assert.IsTrue (Object.ReferenceEquals (key2, key3), "DataKey returns the same instans");
			
			Assert.AreEqual (1001, key1.Value, "DataKey.Value after binding");
			Assert.AreEqual (2, key1.Values.Count, "DataKey.Values count after binding");
			Assert.AreEqual (1001, key1.Values [0], "DataKey.Values[0] after binding");
			Assert.AreEqual ("Mahesh", key1.Values [1], "DataKey.Values[1] after binding");

			Poker copy = new Poker ();
			object state = fv.DoSaveControlState ();
			copy.DoLoadControlState (state);

			DataKey key4 = copy.DataKey;

			Assert.AreEqual (1001, key4.Value, "DataKey.Value from ViewState");
			Assert.AreEqual (2, key4.Values.Count, "DataKey.Values count from ViewState");
			Assert.AreEqual (1001, key4.Values [0], "DataKey.Values[0] from ViewState");
			Assert.AreEqual ("Mahesh", key4.Values [1], "DataKey.Values[1] from ViewState");
		}
		public void FormView_PageCount () {
			Page p = new Page ();

			Poker fv = new Poker ();
			p.Controls.Add (fv);

			ObjectDataSource data = new ObjectDataSource ();
			data.TypeName = typeof (FormViewDataObject).AssemblyQualifiedName;
			data.SelectMethod = "Select";
			p.Controls.Add (data);

			fv.DataSource = data;

			Assert.AreEqual (0, fv.PageCount, "PageCount before binding");

			fv.DataBind ();
			
			Assert.AreEqual (3, fv.PageCount, "PageCount after binding");
		}
		public void FormView_ChangeMode ()
		{
			Poker fv = new Poker ();
			Assert.AreEqual (FormViewMode.ReadOnly, fv.CurrentMode, "ChangeModeDefault");
			fv.ChangeMode (FormViewMode.Insert);
			Assert.AreEqual (FormViewMode.Insert, fv.CurrentMode, "ChangeModeInsert");
			fv.ChangeMode (FormViewMode.Edit);
			Assert.AreEqual (FormViewMode.Edit, fv.CurrentMode, "ChangeModeEdit");
			fv.ChangeMode (FormViewMode.ReadOnly);
			Assert.AreEqual (FormViewMode.ReadOnly, fv.CurrentMode, "ChangeModeReadOnly");
		}
		public void FormView_PrepareControlHierarchy ()
		{
			Poker fv = new Poker ();
			fv.Page = new Page ();
			fv.controlHierarchy = false;
			fv.Render ();
			Assert.AreEqual (0, fv.Controls.Count, "ControlHierarchy1");
			Assert.AreEqual (true, fv.controlHierarchy, "ControlHierarchy2");
			fv.AllowPaging = true;
			fv.DataSource = myds;
			fv.DataBind ();
			fv.controlHierarchy = false;
			fv.Render ();
			Assert.AreEqual (1, fv.Controls.Count, "ControlHierarchy3");
			Assert.AreEqual (true, fv.controlHierarchy, "ControlHierarchy4");


		}
		public void FormView_CreateChildControls ()
		{
			Poker fv = new Poker ();
			fv.DataSource = myds;
			fv.Page = new Page ();
			Assert.AreEqual (6, fv.DoCreateChildControls (myds, true), "CreateChildControlFromDS");
			myds.Add ("item7");
			Assert.AreEqual (7, fv.DoCreateChildControls (myds, false), "CreateChildControlFromViewState");
			myds.Remove ("item7");

		}
		public void FormView_UpdateItem ()
		{
			Poker fv = new Poker ();
			fv.Page = new Page ();
			fv.DataSource = myds;
			fv.DataBind ();
			fv.ChangeMode (FormViewMode.Edit);
			fv.ItemUpdating += new FormViewUpdateEventHandler (update_item);
			Assert.AreEqual (false, updateItem, "BeforeUpdateItem");
			fv.UpdateItem (false);
			Assert.AreEqual (true, updateItem, "AfterUpdateItem");

		}
		public void FormView_EnsureDataBound ()
		{
			Poker fv = new Poker ();			
			fv.DataSource = myds;			
			fv.DoOnPreRender (EventArgs.Empty);
			Assert.AreEqual (true, fv.ensureDataBound, "EnsureDataBound");
			
		}
		public void FormView_CreateTable ()
		{
			Poker fv = new Poker ();
			Table tb = fv.DoCreateTable ();
			fv.Page = new Page ();
			Assert.AreEqual ("", tb.BackImageUrl , "CreateTable1");
			Assert.AreEqual (0, tb.Rows.Count, "CreateTable2");
			fv.DataSource = myds;
			fv.DataBind ();			
			fv.ID = "TestFormView";
			tb = fv.DoCreateTable ();
			Assert.AreEqual (-1, tb.CellPadding , "CreateTable3");			

		}
		public void FormView_CreateRow ()
		{
			Poker fv = new Poker ();
			fv.AllowPaging =true;
			fv.DataSource = myds;
			fv.Page = new Page ();
			fv.DataBind ();
			FormViewRow row = fv.DoCreateRow (2,DataControlRowType.DataRow ,DataControlRowState.Normal );
			Assert.AreEqual (2, row.ItemIndex, "CreatedRowItemIndex1");
			Assert.AreEqual (DataControlRowState.Normal , row.RowState, "CreatedRowState1");
			Assert.AreEqual (DataControlRowType.DataRow , row.RowType, "CreatedRowType1");			 
			row = fv.DoCreateRow (4, DataControlRowType.Footer, DataControlRowState.Edit);
			Assert.AreEqual (4, row.ItemIndex, "CreatedRowItemIndex2");
			Assert.AreEqual (DataControlRowState.Edit , row.RowState, "CreatedRowState2");
			Assert.AreEqual (DataControlRowType.Footer , row.RowType, "CreatedRowType2");
			//FormViewPagerRow pagerRow = (FormViewPagerRow)fv.DoCreateRow (3, DataControlRowType.Pager , DataControlRowState.Insert);
			//Assert.AreEqual (3, pagerRow.ItemIndex, "CreatedPageRowItemIndex");
			//Assert.AreEqual (DataControlRowState.Insert, pagerRow.RowState, "CreatedPageRowState");
			//Assert.AreEqual (DataControlRowType.Pager, pagerRow.RowType, "CreatedPageRowType");			 
			
		}
		public void FormView_InitializePager ()
		{
			Poker fv = new Poker ();
			Page page = new Page ();
			page.Controls.Add (fv);
			fv.AllowPaging = true;
			fv.DataSource = myds;
			Assert.AreEqual (false, fv.isInitializePager, "BeforeInitializePager");
			Assert.AreEqual (0, fv.PageCount, "BeforeInitializePagerPageCount");
			fv.DataBind ();
			Assert.AreEqual (true, fv.isInitializePager, "AfterInitializePager");
			Assert.AreEqual (6, fv.PageCount, "AfterInitializePagerPageCount");
		}
		public void FormView_CreateControlStyle ()
		{
			Poker fv = new Poker ();
			Style s = fv.DoCreateControlStyle ();
			Assert.AreEqual (typeof (TableStyle), s.GetType (), "CreateControlStyle1");
			Assert.AreEqual (GridLines.None, ((TableStyle) s).GridLines, "CreateControlStyle2");
			Assert.AreEqual ("", ((TableStyle) s).BackImageUrl, "CreateControlStyle3");
			Assert.AreEqual (0, ((TableStyle) s).CellSpacing, "CreateControlStyle4");
			Assert.AreEqual (-1, ((TableStyle) s).CellPadding, "CreateControlStyle5");

		}
		public void FormView_CreateDataSourceSelectArguments ()
		{
			//Checks the default DataSourceSelectArgument object returned.
			Poker fv = new Poker ();
			DataSourceSelectArguments selectArgs = fv.DoCreateDataSourceSelectArguments ();
			Assert.AreEqual (0, selectArgs.MaximumRows, "CreateDataSourceSelectArguments1");
			Assert.AreEqual (false, selectArgs.RetrieveTotalRowCount, "CreateDataSourceSelectArguments2");						

		}
		public void FormView_CreateChildControls2 ()
		{
			Poker fv = new Poker ();
			fv.Page = new Page ();
			fv.DataSource = new MyEnumSource (20);
			fv.DataBind ();
			
			Assert.AreEqual (20, fv.PageCount, "CreateChildControls#0");

			Assert.AreEqual (0, fv.DoCreateChildControls (new MyEnumSource (0), true), "CreateChildControls#1");
			Assert.AreEqual (20, fv.DoCreateChildControls (new MyEnumSource (20), true), "CreateChildControls#2");

			Assert.AreEqual (0, fv.DoCreateChildControls (new object [0], false), "CreateChildControls#3");
			Assert.AreEqual (5, fv.DoCreateChildControls (new object [5], false), "CreateChildControls#4");
		}
		public void FormView_DeleteItem ()
		{
			Poker fv = new Poker ();
			fv.Page = new Page ();
			fv.DataSource = myds;
			fv.DataBind ();
			Assert.AreEqual (false, isDeleted, "BeforeDeleteItem");
			fv.ItemDeleting += new FormViewDeleteEventHandler (fv_DeleteingHandler);
			fv.DeleteItem ();
			Assert.AreEqual (true, isDeleted, "BeforeDeleteItem");

		}
		public void FormView_InsertItem ()
		{
			Poker fv = new Poker ();
			fv.Page = new Page ();
			fv.ChangeMode (FormViewMode.Insert);
			fv.ItemInserting += new FormViewInsertEventHandler (insert_item);
			Assert.AreEqual (false, insertItem, "BeforeInsertItem");
			fv.InsertItem (false);
			Assert.AreEqual (true, insertItem, "AfterInsertItem");

		}
		public void FormView_PerformDataBinding ()
		{
			Poker fv = new Poker ();
			fv.Page = new Page ();
			Assert.AreEqual (0,fv.DataItemCount, "BeforePerformDataBinding"); 
			fv.DoPerformDataBinding (myds);
			Assert.AreEqual (6, fv.DataItemCount, "AfterPerformDataBinding"); 
		}
		public void FormView_IsBindableType ()
		{
			bool isBindable = false;
			Poker fv = new Poker ();
			isBindable = fv.IsBindableType (typeof (Decimal));
			Assert.AreEqual (true, isBindable, "IsBindableTypeDecimal");
			isBindable = fv.IsBindableType (typeof (Int32));
			Assert.AreEqual (true, isBindable, "IsBindableTypeInt32");
			isBindable = fv.IsBindableType (typeof (String));
			Assert.AreEqual (true, isBindable, "IsBindableTypeString");
			isBindable = fv.IsBindableType (typeof (Boolean));
			Assert.AreEqual (true, isBindable, "IsBindableTypeBoolean");
			isBindable = fv.IsBindableType (typeof (DateTime));
			Assert.AreEqual (true, isBindable, "IsBindableTypeDateTime");
			isBindable = fv.IsBindableType (typeof (Byte));
			Assert.AreEqual (true, isBindable, "IsBindableTypeByte");
			isBindable = fv.IsBindableType (typeof (Guid));
			Assert.AreEqual (true, isBindable, "IsBindableTypeGuid");
			isBindable = fv.IsBindableType (typeof (MyTemplate));
			Assert.AreEqual (false, isBindable, "IsBindableTypeMyTemplate");
		}
		public void FormView_ExtractRowValues ()
		{
			Poker fv=new Poker ();
			fv.ItemTemplate = new MyTemplate ();
			fv.DataKeyNames = new string[] { "ID", "FName", "LName" };
			//IOrderedDictionary dict = (IOrderedDictionary) new OrderedDictionary (0x19);
			//fv.DoExtractRowValues (dict, true);			
			//DataTable ds = CreateDataTable ();
			//fv.DataSource = ds;
			//fv.DataBind ();
			//OrderedDictionary fieldsValues = new OrderedDictionary ();
			//fv.DoExtractRowValues (fieldsValues, true);
			//Assert.AreEqual (3, fieldsValues.Count, "ExtractRowValues1");
			//Assert.AreEqual (3, fieldsValues.Keys.Count, "ExtractRowValues2");
			//Assert.AreEqual (3, fieldsValues.Values.Count, "ExtractRowValues3");
			//Assert.AreEqual (true, fieldsValues.Contains ("ID"), "ExtractRowValues4");
			//IDictionaryEnumerator enumerator = fieldsValues.GetEnumerator ();
			//enumerator.MoveNext ();
			//Assert.AreEqual ("ID", enumerator.Key, "FieldValue1");
			//Assert.AreEqual ("1001", enumerator.Value, "FieldValue2");
			//enumerator.MoveNext ();
			//Assert.AreEqual ("FName", enumerator.Key, "FieldValue3");
			//Assert.AreEqual ("Mahesh", enumerator.Value, "FieldValue4");
			//enumerator.MoveNext ();
			//Assert.AreEqual ("LName", enumerator.Key, "FieldValue5");
			//Assert.AreEqual ("Chand", enumerator.Value, "FieldValue6");		
  
		}