public void should_get_the_right_number_of_cards_youve_requested()
{
var deck = new DeckOfCards();
var hand = deck.DealHand(5);
hand.Cards.Count.ShouldEqual(5);
}
public void should_have_52_cards()
{
var deck = new DeckOfCards();
deck.Cards.Count().ShouldEqual(52);
deck.Cards[0].Suit.ShouldEqual(Suit.Hearts);
deck.Cards[13].Suit.ShouldEqual(Suit.Diamonds);
deck.Cards[26].Suit.ShouldEqual(Suit.Clubs);
deck.Cards[39].Suit.ShouldEqual(Suit.Spades);
}
public void should_remove_cards_from_deck_after_hand_is_dealt()
{
var deck = new DeckOfCards();
var hand = deck.DealHand(5);
deck.Cards.Count.ShouldEqual(47);
var anotherHand = deck.DealHand(5);
deck.Cards.Count.ShouldEqual(42);
}
public void two_dealt_cards_should_never_be_the_same()
{
var deck = new DeckOfCards();
var card1 = deck.DealCard();
deck.Cards.Count.ShouldEqual(51);
var card2 = deck.DealCard();
card1.ShouldNotEqual(card2);
}
public void RunCardDemo()
{
DeckOfCards myDeck = new DeckOfCards();
myDeck.Shuffle();
DisplayCards(myDeck);
Player me = new Player(), you = new Player(), friend = new Player();
myDeck.Deal(5, me, you, friend);
DisplayPlayerCards(me,"me");
DisplayPlayerCards(you,"you");
//Uh-oh not so secure...
myDeck.Cards.Add(new Card(Suit.SPADES, CardFace.Ace));
myDeck.Cards.Add(new Card(Suit.SPADES, CardFace.Ace));
myDeck.Cards.Add(new Card(Suit.SPADES, CardFace.Ace));
Console.WriteLine("There are {0} cards in the deck.", myDeck.Cards.Count);
}
// execute application
public static void Main( string[] args )
{
DeckOfCards myDeckOfCards = new DeckOfCards();
myDeckOfCards.Shuffle(); // place Cards in random order
myDeckOfCards.MakeHand();
myDeckOfCards.CountSuits();
myDeckOfCards.CountFaces();
// display all 52 Cards in the order in which they are dealt
//for ( int i = 0; i < 52; ++i )
//{
// Console.Write( "{0,-19}", myDeckOfCards.DealCard() );
// if ( ( i + 1 ) % 4 == 0 )
// Console.WriteLine();
//} // end for
}
public void RunCardDemo()
{
DeckOfCards myDeck = new DeckOfCards();
myDeck.Shuffle();
DisplayCards(myDeck);
Player me = new Player(), you = new Player(), friend = new Player();
myDeck.Deal(5, me, you, friend);
// uh-oh - not so secure.....
myDeck.Cards.Add(new Card(Suit.SPADES, CardFace.Ace));
myDeck.Cards.Add(new Card(Suit.SPADES, CardFace.Ace));
myDeck.Cards.Add(new Card(Suit.SPADES, CardFace.Ace));
Console.WriteLine("There are {0} cards in the deck", myDeck.Cards.Count);
// this won't compile...
// myDeck.Cards = new List<Card>();
}
public ActionResult Index()
{
DeckOfCards newDeck = new DeckOfCards();
newDeck.Shuffle();
StringBuilder handString = new StringBuilder();
List<card> pokerHand = new List<card>();
for (int i = 0; i < 5; i++)
{
card newCard = newDeck.DealCard();
handString.Append(newCard.ToString());
pokerHand.Add(newCard);
}
ViewBag.pair = hasPair(pokerHand);
ViewBag.pokerHand = handString.ToString();
return View();
}
public void ShuffleDeck()
{
var randNum = new Random();
int randIndex;
var shuffledDeck = new List <ICard>();
Console.WriteLine("The Deck is Shuffled");
while (DeckOfCards.Count > 0)
{
randIndex = randNum.Next(DeckOfCards.Count - 1);
shuffledDeck.Add(DeckOfCards[randIndex]);
DeckOfCards.RemoveAt(randIndex);
}
DeckOfCards = shuffledDeck;
foreach (ICard card in DeckOfCards)
{
Console.WriteLine(card.Suit + " " + card.Value);
}
}
public void TestSetDeck()
{
DeckOfCards deck = new DeckOfCards();
List <Card> cards = new List <Card>();
Card[] threeCards = { new Card(Suit.Spades, FaceValue.Two),
new Card(Suit.Spades, FaceValue.Three),
new Card(Suit.Spades, FaceValue.Four) };
cards.Add(new Card(Suit.Spades, FaceValue.Two));
cards.Add(new Card(Suit.Spades, FaceValue.Three));
cards.Add(new Card(Suit.Spades, FaceValue.Four));
deck.SetDeck(cards);
IEnumerable <Tuple <Card, Card> > deckAndTestCardListMultpleEnumerator =
MultipleIterate.Over(deck.GetCardEnumerator(), threeCards);
foreach (var decksTuple in deckAndTestCardListMultpleEnumerator)
{
Assert.AreEqual(decksTuple.Item1, decksTuple.Item2);
}
}
public void River()
{
Console.WriteLine("********START TEST River()********");
Card[] sortedPlayerHand;
Card[] playerHand;
DeckOfCards myD = new DeckOfCards();
playerHand = new Card[7];
sortedPlayerHand = new Card[7];
myD.SetUpDeck();
for (int i = 6; i < 7; i++)
{
playerHand[i] = myD.getDeck[i + 2]; //7
}
Assert.IsNotNull(playerHand[6]);
Assert.IsNull(playerHand[5]);
Console.WriteLine("********SUCCESS TEST River()********");
}
//excute application
static void Main(string[] args)
{
try //exception handling
{
DeckOfCards myDeckOfCards = new DeckOfCards();
myDeckOfCards.Shuffle(); //place cards in random order
//print all 52 cards in the order in which they are dealt
for (int i = 1; i <= 52; i++)
{
Console.Write("{0,-25}", myDeckOfCards.dealCard()); //deal and display a card
if (i % 3 == 0) //output a new line after every third card
{
Console.WriteLine();
}
} //end for
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey();
} //end main
public JsonResult AceUpTheSleeve()
{
DeckOfCards deck;
if (Session[SESSION_DECK] == null)
{
deck = new DeckOfCards();
}
else
{
deck = (DeckOfCards)Session[SESSION_DECK];
}
// Add card in parallel
Task task = new Task(() => {
deck.AceUpTheSleeve();
Session[SESSION_DECK] = deck; // Update deck in session
});
task.Start();
return(Json(deck, JsonRequestBehavior.AllowGet));
}
public void TestLastCardDelt()
{
var deck = new DeckOfCards();
var hand = new Hand();
hand.GetACard(deck);
var card = hand.LastCardDelt;
Assert.AreEqual(Card.Suits.Heart, card.Suit);
Assert.AreEqual(1, card.Value);
var trashHand = new Hand();
trashHand.GetACard(deck);
trashHand.GetACard(deck);
trashHand.GetACard(deck);
trashHand.GetACard(deck);
trashHand.GetACard(deck);
card = trashHand.LastCardDelt;
Assert.AreEqual(Card.Suits.Heart, card.Suit);
Assert.AreEqual(6, card.Value);
}
public void ReturnCardTest()
{
var deck = new DeckOfCards();
deck.Shuffle();
// Draw a card and then return it to the bottom
// of the deck
var expected = deck.Draw();
var result = deck.ReturnCard(expected);
var actual = deck[52];
Assert.IsTrue(result);
// Make sure the same card is at place 52
Assert.AreEqual(expected, actual);
// Make sure you cant return an already existing card
// to the deck
expected = deck[26];
result = deck.ReturnCard(expected);
actual = deck[52];
Assert.IsFalse(result);
Assert.AreNotEqual(expected, actual);
}
// Execute app.
static void Main()
{
Console.WriteLine("Wellcome to Card Dealing app.");
Console.WriteLine();
var myDeckOfCards = new DeckOfCards();
// Place Cards in random order.
myDeckOfCards.Shuffle();
Console.WriteLine("The order of cards if the deck before dealing a hand:");
// Print all cards that currently in deck.
myDeckOfCards.PrintDeck();
Console.WriteLine();
Console.WriteLine("Here is your hand:");
// Deal and print a hand.
myDeckOfCards.DealAndPrintHand();
// Print a rand of the hand.
Console.WriteLine($"You have {myDeckOfCards.PrintRank()} in your hand.");
Console.WriteLine();
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
public void PlayTrick(DeckOfCards playerOne, DeckOfCards playerTwo)
{
try
{
var cardPlayerOne = playerOne.Deal(1).Cards[0];
var cardPlayerTwo = playerTwo.Deal(1).Cards[0];
var playerOneWins = false;
if (cardPlayerOne.SameRankAs(cardPlayerTwo))
{
playerOneWins = PlayerOneWinsWar(playerOne, playerTwo);
}
else if (cardPlayerOne.Beats(cardPlayerTwo))
{
playerOneWins = true;
}
if (playerOneWins)
{
//Console.WriteLine("{0} beats {1} - cards to player 1", cardPlayerOne.Name, cardPlayerTwo.Name);
playerOne.Add(cardPlayerOne);
playerOne.Add(cardPlayerTwo);
}
else
{
//Console.WriteLine("{0} beats {1} - cards to player 2", cardPlayerTwo.Name, cardPlayerOne.Name);
playerTwo.Add(cardPlayerOne);
playerTwo.Add(cardPlayerTwo);
}
}
catch
{
// move along
}
}
public void TestTotalError()
{
var deck = new DeckOfCards();
var player = new Player("Testing");
player.GetCard(deck);
deck.GetNextCard();
deck.GetNextCard();
deck.GetNextCard();
deck.GetNextCard();
deck.GetNextCard();
deck.GetNextCard();
player.GetCard(deck);
Assert.AreEqual(19, player.PlayerHand.TotalHand());
deck = new DeckOfCards();
player = new Player("Testing");
deck.GetNextCard();
player.GetCard(deck);
deck.GetNextCard();
deck.GetNextCard();
deck.GetNextCard();
deck.GetNextCard();
deck.GetNextCard();
player.GetCard(deck);
Assert.AreEqual(10, player.PlayerHand.TotalHand());
deck = new DeckOfCards();
player = new Player("Testing");
deck.GetNextCard();
player.GetCard(deck);
deck.GetNextCard();
deck.GetNextCard();
deck.GetNextCard();
player.GetCard(deck);
Assert.AreEqual(8, player.PlayerHand.TotalHand());
}
public List <Card> GetCardsForPlayer(int handID, string username)
{
List <Card> output = new List <Card>();
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand("SELECT * FROM hand_cards WHERE player = @username AND hand_id = @handID;", conn);
cmd.Parameters.AddWithValue("@username", username);
cmd.Parameters.AddWithValue("@handID", handID);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
Card c = new Card();
c.Number = Convert.ToInt32(reader["card_number"]);
c.Suit = Convert.ToString(reader["card_suit"]);
c.Dealt = Convert.ToBoolean(reader["dealt"]);
c.Discard = Convert.ToBoolean(reader["discarded"]);
output.Add(c);
}
}
}
catch (SqlException)
{
throw;
}
return(DeckOfCards.GetSuitAndLetterValues(output));
}
public void Сroupier(int countPlayer)
{
int rankCard = 1;
foreach (var type in new[] { "шестерка", "семерка", "восмерка", "девятка", "десятка", "валет", "дама", "король", "туз" })
{
foreach (var suit in new[] { "черви", "бубни", "крести", "пики" })
{
DeckOfCards.Add(new Card {
Rank = rankCard, Type = type, Suit = suit
});
}
rankCard++;
}
var rand = new Random();
for (int i = 0; i < DeckOfCards.Count; i++)
{
var tmp = DeckOfCards[i];
DeckOfCards.RemoveAt(i);
DeckOfCards.Insert(rand.Next(DeckOfCards.Count), tmp);
}
int countCardForPlayer = /*Koloda.Count / countPlayer*/ 2; // для теста поставил число 2
for (int j = 0; j < countPlayer; j++)
{
Players.Add(new Player());
for (int i = 0; i < countCardForPlayer; i++)
{
Players[j].Import.Add(DeckOfCards.First());
DeckOfCards.Remove(DeckOfCards.First());
}
}
}
public ActionResult <IEnumerable <bool> > Post(string str, object o)
{
switch (str)
{
case "skupkartica":
DeckOfCards deckOfCards = JsonConvert.DeserializeObject <DeckOfCards>(o.ToString(), new IsoDateTimeConverter {
DateTimeFormat = "dd-MM-yyyy"
});
return(Ok(_repository.Add(deckOfCards)));
case "kartica":
Card card = JsonConvert.DeserializeObject <Card>(o.ToString());
return(Ok(_repository.Add(card)));
case "login":
User u = new User();
u.Username = JObject.FromObject(o).SelectToken("username").Value <string>();
if (string.IsNullOrWhiteSpace(u.Username))
{
return(NotFound("Username nije unet"));
}
u.Password = JObject.FromObject(o).SelectToken("password").Value <string>();
if (string.IsNullOrWhiteSpace(u.Password))
{
return(NotFound("Password nije unet"));
}
return(Ok(_repository.Login(u)));
case "korisnik":
User user = new User();
user.Username = JObject.FromObject(o).SelectToken("Username").Value <string>();
user.Password = JObject.FromObject(o).SelectToken("Password").Value <string>();
if (string.IsNullOrWhiteSpace(user.Password))
{
return(NotFound("Stari password nije unet"));
}
//novi password cuvam u mejlu
user.Email = JObject.FromObject(o).SelectToken("Email").Value <string>();
if (string.IsNullOrWhiteSpace(user.Password))
{
return(NotFound("Novi password nije unet"));
}
return(Ok(_repository.Update(user)));
case "podkomentar":
SubComment subComment = JsonConvert.DeserializeObject <SubComment>(o.ToString());
return(Ok(_repository.Add(subComment)));
case "like":
Like like = JsonConvert.DeserializeObject <Like>(o.ToString());
return(Ok(_repository.Add(like)));
case "komentar":
Comment comment = JsonConvert.DeserializeObject <Comment>(o.ToString());
return(Ok(_repository.Add(comment)));
default:
return(NotFound(false));
}
}
/// <summary>
/// Creates a new game of Five Card Draw with a deckof 52 cards.
/// </summary>
public FiveCardDraw()
{
deckOfCards = new DeckOfCards();
deckOfCards.Shuffle();
PlayerHand = new List <Card>();
}
public void should_throw_if_deck_doesnt_have_enough_cards()
{
var deck = new DeckOfCards();
var hand = deck.DealHand(80);
}
public void CreateGame(int countDecks)
{
Deck = new DeckOfCards(countDecks);
Deck.ShuffleDeck();
}
private void DisplayCards(DeckOfCards myDeck)
{
//Just display all the cards
foreach (Card item in myDeck.Cards)
Console.WriteLine("{0} of {1}", item.Face, item.Suit);
}
public GuessTheCardGame()
{
InitializeComponent();
_deckToPick = new DeckOfCards();
}
private void Awake()
{
deckOfCards = this;
textFile = (TextAsset)Resources.Load(("words3.501"), typeof(TextAsset));
}
public GameState(DeckOfCards deckOfCards)
{
Players = new List <Player>();
CardsOnBoard = new List <Card>();
DeckOfCards = deckOfCards;
}
public void TestDeckOfCardsShuffle()
{
DeckOfCards deck = new DeckOfCards();
List <Card> cards = new List <Card>();
cards.Add(new Card(Suit.Spades, FaceValue.Two));
cards.Add(new Card(Suit.Spades, FaceValue.Three));
cards.Add(new Card(Suit.Spades, FaceValue.Four));
deck.SetDeck(cards);
Random anotherRandom = new Random();
List <List <Card> > binOfDecks = new List <List <Card> >();
DeckOfCards temp = new DeckOfCards();
int TWO_THREE_FOUR = 0;
int TWO_FOUR_THREE = 0;
int THREE_TWO_FOUR = 0;
int THREE_FOUR_TWO = 0;
int FOUR_TWO_FOUR = 0;
int FOUR_THREE_FOUR = 0;
for (int shuffleOverload = 0; shuffleOverload < 3; shuffleOverload++)
{
for (int i = 0; i < 1000; i++)
{
switch (shuffleOverload)
{
case 0:
deck.Shuffle();
break;
case 1:
deck.Shuffle(new DeckOfCards(cards));
break;
case 2:
deck.Shuffle(new DeckOfCards(cards), anotherRandom);
break;
default:
throw new IndexOutOfRangeException("Shuffle only has three overloads but the shuffleOverload index is not 0,1 or 2");
}
temp = deck.CloneDeck();
//each permumtation
Card[] twoThreeFour = new Card[] { new Card(Suit.Spades, FaceValue.Two), new Card(Suit.Spades, FaceValue.Three), new Card(Suit.Spades, FaceValue.Four) };
Card[] twoFourThree = new Card[] { new Card(Suit.Spades, FaceValue.Two), new Card(Suit.Spades, FaceValue.Four), new Card(Suit.Spades, FaceValue.Three) };
Card[] threeTwoFour = new Card[] { new Card(Suit.Spades, FaceValue.Three), new Card(Suit.Spades, FaceValue.Two), new Card(Suit.Spades, FaceValue.Four) };
Card[] threeFourTwo = new Card[] { new Card(Suit.Spades, FaceValue.Three), new Card(Suit.Spades, FaceValue.Four), new Card(Suit.Spades, FaceValue.Two) };
Card[] fourTwoThree = new Card[] { new Card(Suit.Spades, FaceValue.Four), new Card(Suit.Spades, FaceValue.Two), new Card(Suit.Spades, FaceValue.Three) };
Card[] fourThreeFour = new Card[] { new Card(Suit.Spades, FaceValue.Four), new Card(Suit.Spades, FaceValue.Three), new Card(Suit.Spades, FaceValue.Two) };
//bins
TWO_THREE_FOUR += temp.CardDeck.SequenceEqual(twoThreeFour) == true ? 1 : 0;
TWO_FOUR_THREE += temp.CardDeck.SequenceEqual(twoFourThree) == true ? 1 : 0;
THREE_TWO_FOUR += temp.CardDeck.SequenceEqual(threeTwoFour) == true ? 1 : 0;
THREE_FOUR_TWO += temp.CardDeck.SequenceEqual(threeFourTwo) == true ? 1 : 0;
FOUR_TWO_FOUR += temp.CardDeck.SequenceEqual(fourTwoThree) == true ? 1 : 0;
FOUR_THREE_FOUR += temp.CardDeck.SequenceEqual(fourThreeFour) == true ? 1 : 0;
}
///TODO find a good way to test randomness. This is not a good way. See commments above this function.
Assert.IsTrue((TWO_THREE_FOUR < 333) && (TWO_THREE_FOUR > 88));
Assert.IsTrue((TWO_FOUR_THREE < 333) && (TWO_FOUR_THREE > 88));
Assert.IsTrue((THREE_TWO_FOUR < 333) && (THREE_TWO_FOUR > 88));
Assert.IsTrue((THREE_FOUR_TWO < 333) && (THREE_FOUR_TWO > 88));
Assert.IsTrue((FOUR_TWO_FOUR < 333) && (FOUR_TWO_FOUR > 88));
Assert.IsTrue((FOUR_THREE_FOUR < 333) && (FOUR_THREE_FOUR > 88));
TWO_THREE_FOUR = 0;
TWO_FOUR_THREE = 0;
THREE_TWO_FOUR = 0;
THREE_FOUR_TWO = 0;
FOUR_TWO_FOUR = 0;
FOUR_THREE_FOUR = 0;
///TODO go here and read and finish data base connection
/* https://msdn.microsoft.com/en-us/library/bb384428.aspx
* using (var db = new TestShuffleResults())
* {
* db.(new TestDeckOfCardsShuffleUnitTestResult
* { tWO_THREE_FOUR = TWO_THREE_FOUR, tWO_FOUR_THREE = TWO_FOUR_THREE , tHREE_TWO_FOUR = THREE_TWO_FOUR,
* tHREE_FOUR_TWO = THREE_TWO_FOUR, fOUR_TWO_FOUR = FOUR_TWO_FOUR, fOUR_THREE_FOUR = FOUR_THREE_FOUR });
* db.SaveChanges();
*
*
*/
}
}
public void DoHit(DeckOfCards deck)
{
PlayerHand.GetACard(deck);
HandOver();
}
public void GetCards_ShouldBeListOfCards()
{
IDeckOfCards sut = new DeckOfCards();
Assert.IsInstanceOf <IList <Card> >(sut.GetCards());
}
public void DeckTestsInitalize()
{
_Deck = new DeckOfCards();
}
// Use this for initialization
void Start()
{
deck = GetComponent <DeckOfCards>();
ShowCards();
}
public CardGame()
{
deck = new DeckOfCards();
}
public void setupBeforeEachTest()
{
d = new DeckOfCards();
}
public bool Update(Object o)
{
try
{
switch (o)
{
case User u:
User userDatabase = _fscontext.Users.Where(x => x.Username == u.Username).FirstOrDefault <User>();
if (userDatabase != null)
{
if (u.Password != userDatabase.Password)
{
return(false);
}
userDatabase.Password = u.Email;
_fscontext.Update(userDatabase);
_fscontext.SaveChanges();
return(true);
}
return(false);
case DeckOfCards d:
DeckOfCards deckOfCards = _fscontext.DecksOfCards.Where(x => x.DeckOfCardsID == d.DeckOfCardsID).FirstOrDefault <DeckOfCards>();
List <Card> cardsDatabase = _fscontext.Cards.Where(x => x.DeckOfCards.DeckOfCardsID == d.DeckOfCardsID).ToList();
List <Card> cardsUser = d.Cards;
if (deckOfCards != null)
{
deckOfCards.Name = d.Name;
_fscontext.Update(deckOfCards);
_fscontext.SaveChanges();
for (int i = 0; i < cardsDatabase.Count; i++)
{
for (int j = 0; j < cardsUser.Count; j++)
{
if (cardsDatabase[i].CardID == cardsUser[j].CardID)
{
cardsDatabase[i].TextFront = cardsUser[j].TextFront;
cardsDatabase[i].TextBack = cardsUser[j].TextBack;
_fscontext.Update(cardsDatabase[i]);
_fscontext.SaveChanges();
}
}
}
return(true);
}
return(false);
default:
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public void BasicTest()
{
string[] deck = DeckOfCards.BuildDeck();
Assert.AreEqual(52, deck.Length, "Your deck should have 52 cards");
}
