PHPUnit: Toleranzen

[ApoY2k]

Hallo ihr,

bin relativ frisch in das Thema PHPUnit eingestiegen und habe eine Frage; Ich möchte eine Methode testen, die ein Array mischt. (z. B. ein Array mit Karten, die ich mischen möchte).

Dafür habe ich mir folgendes zusammen gezimmert:

foreach ($this as $object)
{
    $tmp_index = $this->indexOf($object);
    $new_index = array_rand($this->toArray());
    $tmp_object = $this->get($new_index);
    
    // Switch the positions of the two objects
    $this->set($new_index, $object);
    $this->set($tmp_index, $tmp_object);
} 

Um diese Methode zu testen, habe ich folgenden TestCase geschrieben:

$before = $this->deck;
$this->deck->shuffle();
$after = $this->deck;

foreach ($this->deck as $item)
{
    $old_index = $before->indexOf($item);
    $new_index = $before->indexOf($item);
    $this->assertNotEquals($old_index, $new_index);
} 

Dieser schlägt immer fehl. Ich weiß auch warum: Das erste Element bleibt immer auf dem gleichen Index.

Das heißt, ich habe zwei Möglichkeiten: Ich schreibe shuffle() um, jedoch weiß ich da nicht genau wie ich es am dümmsten machen soll - hat jemand eine Anregung, wie man das Mischen eines Arrays besser erledigen kann?

Zweitens: Ich ermögliche dem Test, eine gewissen Toleranz zu haben. Beim Mischen werden ja auch nie alle Karten an eine andere Stelle gemischt, manche können auch nach dem Mischen noch an der gleichen Stelle sein. Wie könnte ich dem TestCase das beibringen, dass er erst fehl schlägt, wenn z. B. über 25% der Karten nicht an einem anderen Index liegen?

[AmicaNoctis]

Hallo,

ich würde einfach PHP: shuffle - Manual nehmen oder hast du einen bestimmten Grund dafür, es nicht zu verwenden?

Gruß,

Amica

[ApoY2k]

Shuffle erwartet ein Array, aber die Klasse die ich "shufflen" möchte, ist selbst geschrieben und damit kann shuffle offensichtlich nicht umgehen :-/

[AmicaNoctis]

Vergleich einfach das alte und das neue Array. Wenn es gemischt wurde, sollte wenigstens ein Wert an einer anderen Stelle stehen, was Ungleichheit verursacht.

[combie]

Bestimmt!
Wenn du dir eine Funktion baust, welche Toleranzen berechnen kann.

[ApoY2k]

Vergleich einfach das alte und das neue Array. Wenn es gemischt wurde, sollte wenigstens ein Wert an einer anderen Stelle stehen, was Ungleichheit verursacht.

Nunja, das ist aber ein ziemlich blödes Mischen dann... Hätte eher gerne was im Sinne von "maximal 2 Karten an der gleichen Stelle"... wie fängt man da an?

[AmicaNoctis]

Das ist auch kein Problem: Vergleich die Arrays und zähl mit, wie oft derselbe Wert demselben Index zugeordnet ist. Diese Anzahl kannst du dann sogar noch ins Verhältnis zur Länge setzen.

[ApoY2k]

Hm, klar... einfach und effektiv. Denken hilft.

Ich danke vielmals für die Hilfe.

PS: Lösung für die Interessierten:

// Create a new deck from the array of the old one, as otherwise $before and $after would point to the same deck
$before = new Deck($this->deck->toArray());
$this->deck->shuffle();
$after = $this->deck;

$same = 0;

foreach ($this->deck as $item)
{
    $old_index = $before->indexOf($item);
    $new_index = $after->indexOf($item);
    
    if ($old_index == $new_index)
        $same++;
}

$this->assertLessThanOrEqual(0.2, $same / $this->deck->count()); 

[h3ll]

Warum nicht einfach

$newDeck = clone $oldDeck;
$newDeck->shuffle();
$numDiff = count(array_diff_assoc($oldDeck->toArray(), $newDeck->toArray())) 

?

[ApoY2k]

Naja... weil ich die Funktion nicht kannte. Danke für den Tip, funktioniert einwandfrei