Einführung

Ich habe ein Janken-Programm in Ruby gemacht. Zu dieser Zeit benutzte ich eine Testeinheit, um zu bestätigen, ob das Urteil über das Gewinnen oder Verlieren richtig war.

Inhaltsverzeichnis

1. Schreiben Sie eine Janken-Methode
Schreiben Sie den Testcode
1. Schreiben Sie ein Janken-Programm
Führen Sie das Programm aus
Führen Sie den Test aus

1. 1. Schreiben Sie eine Janken-Methode

Zuerst werden wir die Methoden von Janken in einer Klasse zusammenstellen. Hier wird keine Standardeingabe / -ausgabe durchgeführt, und nur der Rückgabewert wird zurückgegeben. Diese Methode wird als Teil des Testcodes und des Codes des Rock-Paper-Scissors-Programms verwendet.

`janken_judge.rb`


class Janken
  def self.judge(my_hand, enemy_hand)
    hands = {"g" => "Schmiere", "c" => "Choki", "p" => "Par"}        
    if my_hand == enemy_hand
      "Sie sind#{hands[my_hand]},ICH#{hands[enemy_hand]}, Es ist eine Zeichnung."        
    elsif (my_hand == "g" && enemy_hand == "c") || (my_hand == "c" && enemy_hand == "p") || (my_hand == "p" && enemy_hand == "g")
      "Sie sind#{hands[my_hand]},ICH#{hands[enemy_hand]}, Dein Gewinn."        
    else
      "Sie sind#{hands[my_hand]},ICH#{hands[enemy_hand]}, Du verlierst."        
    end
  end
end

2. Schreiben Sie den Testcode

Ich werde einen Testcode schreiben, der bestätigt, ob das Urteil in allen Mustern unter Verwendung der Testeinheit korrekt ist.

`test_janken.rb`


# 'test/unit'Erfordert einen Methodenteil zum Testen
require 'test/unit'
require_relative 'janken_judge.rb'

# Test::Unit::Erstellen Sie eine Klasse, die TestCase erbt. Der Name ist Test_Erstellen Sie eine Methode, die mit beginnt.
class TestJanken < Test::Unit::TestCase
  def test_janken
#Schreiben Sie einen Test. behaupten behaupten_gleich Erwarteter Wert A.,Testziel B, A.=Wenn B, bestehen Sie den Test. Geben Sie diesmal die Kombination aller Hände und das Ergebnis des Gewinnens oder Verlierens ein.
    assert_equal 'Du bist gut, ich bin gut, zeichne.', Janken.judge("g", "g")
    assert_equal 'Du bist Choki, ich bin Choki, zeichne.', Janken.judge("c", "c")
    assert_equal 'Du bist par, ich bin par, zeichne.', Janken.judge("p", "p")
    assert_equal 'Du bist gut, ich bin Choki, du gewinnst.', Janken.judge("g", "c")
    assert_equal 'Du bist Choki, ich bin par, du gewinnst.', Janken.judge("c", "p")
    assert_equal 'Du bist par, ich bin goo, du gewinnst.', Janken.judge("p", "g")
    assert_equal 'Du bist gut, ich bin par, du verlierst.', Janken.judge("g", "p")
    assert_equal 'Du bist Choki, ich bin goo, du verlierst.', Janken.judge("c", "g")
    assert_equal 'Du bist par, ich bin choki, du verlierst.', Janken.judge("p", "c")
  end
end

1. Benötigen Sie zunächst den zuvor geschriebenen Test / unit'and'janken_jedge.rb '.
Erstellen Sie eine Klasse, die Test :: Unit :: TestCase erbt. Erstellen Sie eine Methode, deren Name mit test_ beginnt. Hier ist es test_janken.
1. Schreiben Sie den Test in die erstellte Methode test_janken. Wir verwenden assert_equal, um festzustellen, ob der erwartete Wert mit dem zu testenden Wert übereinstimmt. Dieses Mal haben wir ein Urteil getroffen, das auf der Kombination aller Hände und dem Ergebnis des Gewinnens oder Verlierens basiert.

3. 3. Schreiben Sie ein Janken-Programm

Schließlich werde ich das Janken-Programm schreiben, das die Hauptlogik ist, die tatsächlich ausgeführt wird. Wenn Sie dieses Programm ausführen, wartet es auf die Standardeingabe und die Benutzertypen g, c oder p. Der Computer gibt zufällig Goo, Choki und Par aus, beurteilt den Gewinn oder Verlust und gibt wie folgt aus. Beispiel) Du bist Choki, ich bin Par, du gewinnst.

`janken.rb`


#Erfordert den zuvor erstellten Methodenteil
require_relative 'janken_judge.rb'

#Benutzer g,c,p Geben Sie eine Hand ein
my_hand = gets.chomp
#Der Computer macht zufällige Bewegungen.
enemy_hand = ["g","c","p"].sample

#Das Urteil von Janken wird ausgegeben.
puts Janken.judge(my_hand, enemy_hand)

4. Führen Sie das Programm aus

Lass es uns laufen.

% ruby janken.rb 
g
Du bist gut, ich bin par, du verlierst.

5. Führen Sie den Test aus

Aufgrund der obigen Ergebnisse scheint das Janken-Programm ordnungsgemäß zu funktionieren. Lassen Sie uns einen Test durchführen, um festzustellen, ob alle Muster richtig beurteilt wurden.

% 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
--------------------------------------------------------------------------------

Ich habe 9 Zusicherungen, 0 Fehler, 100% bestanden, sodass ich bestätigen konnte, dass alle Muster den Test bestanden haben.

Wenn Sie jetzt den falschen Code geschrieben haben, versuchen Sie es. Ändern Sie in der Zeile nach dem else in janken_judge.rb "Sie verlieren" in "Sie gewinnen" und versuchen Sie dann, den Test auszuführen.

 % ruby test_janken.rb
Loaded suite test_janken
Started
F
================================================================================
     12:     assert_equal 'Du bist gut, ich bin Choki, du gewinnst.', Janken.judge("g", "c")
     13:     assert_equal 'Du bist Choki, ich bin par, du gewinnst.', Janken.judge("c", "p")
     14:     assert_equal 'Du bist par, ich bin goo, du gewinnst.', Janken.judge("p", "g")
  => 15:     assert_equal 'Du bist gut, ich bin par, du verlierst.', Janken.judge("g", "p")
     16:     assert_equal 'Du bist Choki, ich bin goo, du verlierst.', Janken.judge("c", "g")
     17:     assert_equal 'Du bist par, ich bin choki, du verlierst.', Janken.judge("p", "c")
     18:   end
test_janken.rb:15:in `test_janken'
<"Du bist gut, ich bin par, du verlierst."> expected but was
<"Du bist gut, ich bin par, du gewinnst.">

diff:
?Du bist gut, ich bin par, du verlierst.
?Sieg
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
--------------------------------------------------------------------------------

Er sagte zu mir: "Ich möchte, dass Sie" verlieren "sagen, aber Sie sind" gewinnen "geworden." Ich fand, dass der Test gut funktionierte.

Janken-Programm mit Ruby und seinem Test (Testeinheit)