Bearbeiten von „Datei helper test.dart“

= Link =
* [[Projekt dgrep]]

= Zielsetzung =
Die Datei helper_test.dart enthält die Unittests der [[Datei helper.dart]].

Für jede Funktion aus helper.dart existiert mindestens ein Test.

= Import =
<pre>
import 'dart:io';
import 'package:dgrep/helper.dart';
import 'package:test/test.dart';
import 'package:args/args.dart';
import 'package:path/path.dart' as path;
</pre>
* <code>import 'package:dgrep/helper.dart';</code> Damit kennt der Parser die Definitionen aus helper.dart.
* Die anderen Importe betreffen das interne Paket <code>dart:io</code> und die externen Pakete <code>args</code>, <code>test</code> und <code>path</code>.
* <code>import 'package:path/path.dart' as path;</code> 
** Es gibt folgendes Problem: die Pakete test und path enthalten jeweils eine Funktion <code>equals()</code>.
** Zur Auflösung des Konflikts wird der Zugriffsname <code>path</code> (hinter '''as''') definiert, das bedeutet dass alle Zugriffen auf Namen aus dem Paket mit einem <code>path.</code> erfolgen müssen, beispielsweise <path.join()</code>.
** Der Zugriffsname könnte auch <code>blabla</code> heißen, per Konvention wird aber der Paketname verwendet.

= Die Tests =
<pre>void main() {
 group('argument handling', () {
    test('testIntArguments', () {
      final parser = ArgParser();
      parser.addOption('count');
      parser.addOption('positive-number');
      parser.addFlag('recursive');
      final result = parser
          .parse(['--positive-number', '33', '--recursive', '--count=nix']);
      var message;
      expect(
          testIntArguments(
              result, ['positive-number'], (error) => message = error),
          true);
      expect(
          testIntArguments(
              result, ['positive-number', 'count'], (error) => message = error),
          false);
      expect(message, contains('count is not an integer: nix'));
    });
    test('testRegExpArguments', () {
... 
    });
  });
  test('regExpEscape', () {
    expect(regExpEscape('()[]{}?*+-|^\$\\.&~# '), equals('\\(\\)\\[\\]\\{\\}\\?\\*\\+\\-\\|\\^\\\$\\\\\\.\\&\\~\\#\\ '));
    expect(regExpEscape('abc.123'), equals(r'abc\.123'));
    expect(regExpEscape(''), equals(r''));
    expect(regExpEscape(null), isNull);
  });
  ...
}
</pre>
* <code>group('argument handling', () {</code> Es wird eine Gruppe definiert, die laut Beschreibung die Argumentbehandlung testet, das sind zwei Funktionen <code>testIntArguments()</code> und <code>testRegExpArguments()</code>.
* <code>final parser = ArgParser();</code> Damit beginnt die Vorbereitung auf den Test: ein <code>ArgParser</code>-Objekt wird instantiiert.
* Es werden drei Optionen eingetragen, eines davon ist ein Flag (Boolsche Option).
* <code>result = parser.parse(['--positive-number', '33', '--recursive', '--count=nix']);</code>
** Der Parser untersucht die übergebene Argumentliste auf Optionen.
** Das Ergebnis ist ein Objekt vom Typ <code>ArgResults</code>, das als Parameter für die zu testenden Funktionen <code>testIntArguments()</code> und <code>testRegExpArguments()</code> gebraucht wird.
* Damit ist die Vorbereitung eines "vernünftigen" Tests fertig.
* Die Funktion <code>expect()</code> hat als ersten Parameter den zu testenden Wert, als zweiten den erwarteten Wert.
** Wir testen den Aufruf von <code>testIntArguments()</code> und erwarten den Wert <code>true</code>, da die Option "--positive-number" korrekt benutzt wurde.
** Im zweiten Aufruf wird mit dem Parameter <code>count</code> eine Option getestet, die mit dem String <code>nix</code> falsch vewendet wurde, wir erwarten also als Funktionsergebnis von <code>testIntArguments</code> den Wert <code>false</code>.
* Der dritte Parameter von  <code>testIntArguments()</code> ist eine Callbackfunktion, die eine Fehlermeldung als Parameter übergeben bekommt. In unserem Test speichern wir diese Meldung in der lokalen Variablen <code>message</code>.
* <code>expect(message, contains('excluded: error in regular expression'));</code>
** Hier wird die obige Variable auf die korrekte Fehlermeldung untersucht.
* Nach der Gruppe folgen Tests, die keine Gruppe haben. Das ist korrekt.
* Der erste Test außerhalb der Gruppe hat die Beschreibung 'regExpEscape'.
* Zuerst werden alle Metazeichen auf einmal getestet, ob alle mit dem vorausgehenden Gegenstrich markiert werden.
* Danach folgt der Test von einem gängigen Beispiel mit und ohne Metazeichen.
* Es folgen zwei Tests mit Grenzbereichen, dem Leerstring als Parameter und der <code>null</code>.