introduction

J'ai créé un programme Janken en Ruby. À ce moment-là, j'ai utilisé une unité de test pour confirmer si le jugement de gagner ou de perdre était correct.

table des matières

1. Ecrire une méthode Janken
Écrire le code de test
1. Ecrire un programme Janken
Exécutez le programme
Lancer le test

1. 1. Ecrire une méthode Janken

Tout d'abord, nous allons rassembler les méthodes de Janken dans une classe. Ici, l'entrée / sortie standard n'est pas effectuée et seule la valeur de retour est renvoyée. Cette méthode est utilisée dans le cadre du code de test et du code du programme rock-paper-scissors.

`janken_judge.rb`


class Janken
  def self.judge(my_hand, enemy_hand)
    hands = {"g" => "Goo", "c" => "Choki", "p" => "Par"}        
    if my_hand == enemy_hand
      "vous êtes#{hands[my_hand]},JE#{hands[enemy_hand]}, C'est un tirage au sort."        
    elsif (my_hand == "g" && enemy_hand == "c") || (my_hand == "c" && enemy_hand == "p") || (my_hand == "p" && enemy_hand == "g")
      "vous êtes#{hands[my_hand]},JE#{hands[enemy_hand]}, Votre victoire."        
    else
      "vous êtes#{hands[my_hand]},JE#{hands[enemy_hand]}, Tu as perdu."        
    end
  end
end

2. Écrire le code de test

J'écrirai un code de test qui confirme si le jugement est correct dans tous les modèles à l'aide de test-unit.

`test_janken.rb`


# 'test/unit'Nécessite une partie méthode pour tester avec
require 'test/unit'
require_relative 'janken_judge.rb'

# Test::Unit::Créez une classe qui hérite de TestCase. Le nom est test_Créez une méthode qui commence par.
class TestJanken < Test::Unit::TestCase
  def test_janken
#Écrivez un test. affirmer affirmer_égal Valeur attendue A,Cible de test B, A=Si B, réussissez le test. Cette fois, entrez la combinaison de toutes les mains et le résultat de la victoire ou de la défaite.
    assert_equal 'Vous êtes goo, je suis goo, dessinez.', Janken.judge("g", "g")
    assert_equal 'Tu es choki, je suis choki, dessine.', Janken.judge("c", "c")
    assert_equal 'Vous êtes égal, je suis égal, dessiner', Janken.judge("p", "p")
    assert_equal 'Vous êtes goo, je suis choki, vous gagnez.', Janken.judge("g", "c")
    assert_equal 'Vous êtes choki, je suis égal, vous gagnez.', Janken.judge("c", "p")
    assert_equal 'Vous êtes égal, je suis goo, vous gagnez.', Janken.judge("p", "g")
    assert_equal 'Vous êtes goo, je suis par, vous perdez', Janken.judge("g", "p")
    assert_equal 'Vous êtes choki, je suis goo, vous perdez.', Janken.judge("c", "g")
    assert_equal 'Vous êtes égal, je suis choki, vous perdez.', Janken.judge("p", "c")
  end
end

1. Tout d'abord, require'test / unit'et'janken_jedge.rb 'écrits plus tôt.
Créez une classe qui hérite de Test :: Unit :: TestCase. Créez une méthode dont le nom commence par test_. Ici, c'est test_janken.
1. Écrivez le test dans la méthode test_janken créée. Nous utilisons assert_equal pour déterminer si la valeur attendue correspond à la valeur testée. Cette fois, nous avons fait un jugement basé sur la combinaison de toutes les mains et le résultat de la victoire ou de la défaite.

3. 3. Ecrire un programme Janken

Enfin, j'écrirai le programme Janken, qui est la logique principale réellement exécutée. Lorsque vous exécutez ce programme, il attend l'entrée standard et l'utilisateur tape g, c ou p. L'ordinateur émet aléatoirement goo, choki et par, juge la victoire ou la défaite et sort comme suit. Exemple) Vous êtes Choki, je suis Par, vous gagnez.

`janken.rb`


#Nécessite la partie méthode créée précédemment
require_relative 'janken_judge.rb'

#Utilisateur g,c,p Entrez l'une ou l'autre main
my_hand = gets.chomp
#L'ordinateur effectue des mouvements aléatoires.
enemy_hand = ["g","c","p"].sample

#Le jugement de Janken est sorti.
puts Janken.judge(my_hand, enemy_hand)

4. Exécutez le programme

Lançons-le.

% ruby janken.rb 
g
Vous êtes goo, je suis par, vous perdez

5. Lancer le test

D'après les résultats ci-dessus, le programme Janken semble fonctionner correctement. Faisons un test pour voir si tous les modèles sont jugés correctement.

% ruby test_janken.rb 
Loaded suite test_janken
Started
.
Finished in 0.001524 seconds.
--------------------------------------------------------------------------------
1 tests, 9 assertions, 0 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
100% passed
--------------------------------------------------------------------------------

J'ai eu 9 assertions, 0 échec, 100% réussi, donc j'ai pu confirmer que tous les modèles avaient réussi le test.

Maintenant, si vous avez écrit le mauvais code, essayez-le. Dans la ligne après le else dans janken_judge.rb, remplacez "Vous perdez" par "Vous gagnez", puis essayez d'exécuter le test.

 % ruby test_janken.rb
Loaded suite test_janken
Started
F
================================================================================
     12:     assert_equal 'Vous êtes goo, je suis choki, vous gagnez.', Janken.judge("g", "c")
     13:     assert_equal 'Vous êtes choki, je suis égal, vous gagnez.', Janken.judge("c", "p")
     14:     assert_equal 'Vous êtes égal, je suis goo, vous gagnez.', Janken.judge("p", "g")
  => 15:     assert_equal 'Vous êtes goo, je suis par, vous perdez', Janken.judge("g", "p")
     16:     assert_equal 'Vous êtes choki, je suis goo, vous perdez.', Janken.judge("c", "g")
     17:     assert_equal 'Vous êtes égal, je suis choki, vous perdez.', Janken.judge("p", "c")
     18:   end
test_janken.rb:15:in `test_janken'
<"Vous êtes goo, je suis par, vous perdez"> expected but was
<"Vous êtes bon, je suis égal, vous gagnez">

diff:
?Vous êtes goo, je suis par, vous perdez
?gagner
Failure: test_janken(TestJanken)
================================================================================

Finished in 0.01695 seconds.
--------------------------------------------------------------------------------
1 tests, 7 assertions, 1 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
0% passed
--------------------------------------------------------------------------------

Il m'a dit: "Je veux que vous disiez" perdre ", mais vous êtes devenu" gagnant "." J'ai trouvé que le test fonctionnait bien.

Programme Janken utilisant Ruby et son test (test-unit)