Datei helper test.dart: Unterschied zwischen den Versionen

Aus Info-Theke
Zur Navigation springen Zur Suche springen
(Die Seite wurde neu angelegt: „= Link = * Projekt dgrep = Zielsetzung = Die Datei helper_test.dart enthält die Unittests der Datei helper.dart. Für jede Funktion aus helper.dart…“)
 
 
(2 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 19: Zeile 19:
* <code>import 'package:path/path.dart' as 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>.
** 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>.
** 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 <code>path.join()</code>.
** Der Zugriffsname könnte auch <code>blabla</code> heißen, per Konvention wird aber der Paketname verwendet.
** Der Zugriffsname könnte auch <code>blabla</code> heißen, per Konvention wird aber der Paketname verwendet.


Zeile 74: Zeile 74:
* Danach folgt der Test von einem gängigen Beispiel mit und ohne Metazeichen.
* 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>.
* Es folgen zwei Tests mit Grenzbereichen, dem Leerstring als Parameter und der <code>null</code>.
* Es folgen Tests nach dem gleichen Schema.
Der Test von <code>isBinary()</code> ist deshalb interessant, weil hier erst mal Daten für den Test erstellt werden müssen: Wie schreibe ich binäre Daten in eine Datei?
<pre>test('isBinary', () {
  final base = path.join(Directory.systemTemp.path, 'helper');
  final file1 = path.join(base, 'notBinary.01');
  writeString(file1, string: 'abc\r\n\t\f');
  expect(isBinary(file1), isFalse);
  final file2 = File(path.join(base, 'binary.02'));
  final handle1 = file2.openSync(mode: FileMode.write);
  handle1.writeByteSync(0);
  handle1.writeByteSync(33);
  handle1.closeSync();
  expect(isBinary(file2.path), isTrue);
  final file3 = File(path.join(base, 'binary.02'));
  final handle2 = file3.openSync(mode: FileMode.write);
  for (var no = 1; no < 32; no++) {
    handle2.writeByteSync(no);
  }
  handle2.closeSync();
  expect(isBinary(file3.path), isTrue);
});
</pre>
* <code>final base = path.join(Directory.systemTemp.path, 'helper');</code> Damit der Test plattformunabhängig ist, also unter Linux und Windows funktioniert, fragen wir mit <code>Directory.systemTemp.path</code> den Namen des temporären Verzeichnisses ab, unter Linux ist das '/tmp', unter Windows c:\temp oder ähnliches. Dieses Verzeichnis wird mit der Funktion <code>join()</code> mit dem Unterverzeichnis namens <code>helper</code> ergänzt, so dass in <code>base</code> dann unter Linux <code>/tmp/helper</code> und unter Windows <code>c:\temp\helper</code> steht.
* <code>final file1 = path.join(base, 'notBinary.01');</code> mit der Funktion <code>join</code> aus dem Paket <code>path</code> setzen wir plattformunabhängig einen Dateinamen aus Verzeichnis und Namen zusammen.
* <code>writeString(file1, string: 'abc\r\n\t\f');</code> schreibt einen normalen Text in eine Datei (siehe [[Datei helper.dart]]).
* <code>expect(isBinary(file1), isFalse);</code> Eine normale Textdatei ist nicht binär, wir erwarten als Ergebnis also <code>false</code>.
* <code>final handle1 = file2.openSync(mode: FileMode.write);</code> Damit öffnen wir eine Datei zum Schreiben.
* <code>handle1.writeByteSync(0);</code> Wir schreiben das Byte <code>0</code> in die Datei, danach noch ein weiteres Byte mit der Nummer 33 (das ist das Ausrufezeichen).
* <code>handle1.closeSync();</code> Wer eine Datei öffnet, muss sie auch schließen, sonst werden Resourcen nicht freigegeben.
* Jetzt habe wir eine binäre Datei, die wir testen können. <code>expect(isBinary(file2.path), isTrue);</code>
* Nach unserer Definition liegt auch dann eine Binärdatei vor, wenn mehr als 25% der Zeichen Kontrollzeichen sind.
* <code>for (var no = 1; no < 32; no++)</code> Mit dieser Schleife schreiben wir 30 Zeichen, die meisten Kontrollzeichen, in die zweite Datei.

Aktuelle Version vom 5. Januar 2021, 02:39 Uhr

Link[Bearbeiten]

Zielsetzung[Bearbeiten]

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[Bearbeiten]

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

Die Tests[Bearbeiten]

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);
  });
  ...
}
  • group('argument handling', () { Es wird eine Gruppe definiert, die laut Beschreibung die Argumentbehandlung testet, das sind zwei Funktionen testIntArguments() und testRegExpArguments().
  • final parser = ArgParser(); Damit beginnt die Vorbereitung auf den Test: ein ArgParser-Objekt wird instantiiert.
  • Es werden drei Optionen eingetragen, eines davon ist ein Flag (Boolsche Option).
  • result = parser.parse(['--positive-number', '33', '--recursive', '--count=nix']);
    • Der Parser untersucht die übergebene Argumentliste auf Optionen.
    • Das Ergebnis ist ein Objekt vom Typ ArgResults, das als Parameter für die zu testenden Funktionen testIntArguments() und testRegExpArguments() gebraucht wird.
  • Damit ist die Vorbereitung eines "vernünftigen" Tests fertig.
  • Die Funktion expect() hat als ersten Parameter den zu testenden Wert, als zweiten den erwarteten Wert.
    • Wir testen den Aufruf von testIntArguments() und erwarten den Wert true, da die Option "--positive-number" korrekt benutzt wurde.
    • Im zweiten Aufruf wird mit dem Parameter count eine Option getestet, die mit dem String nix falsch vewendet wurde, wir erwarten also als Funktionsergebnis von testIntArguments den Wert false.
  • Der dritte Parameter von testIntArguments() ist eine Callbackfunktion, die eine Fehlermeldung als Parameter übergeben bekommt. In unserem Test speichern wir diese Meldung in der lokalen Variablen message.
  • expect(message, contains('excluded: error in regular expression'));
    • 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 null.
  • Es folgen Tests nach dem gleichen Schema.

Der Test von isBinary() ist deshalb interessant, weil hier erst mal Daten für den Test erstellt werden müssen: Wie schreibe ich binäre Daten in eine Datei?

test('isBinary', () {
  final base = path.join(Directory.systemTemp.path, 'helper');
  final file1 = path.join(base, 'notBinary.01');
  writeString(file1, string: 'abc\r\n\t\f');
  expect(isBinary(file1), isFalse);
  final file2 = File(path.join(base, 'binary.02'));
  final handle1 = file2.openSync(mode: FileMode.write);
  handle1.writeByteSync(0);
  handle1.writeByteSync(33);
  handle1.closeSync();
  expect(isBinary(file2.path), isTrue);
  final file3 = File(path.join(base, 'binary.02'));
  final handle2 = file3.openSync(mode: FileMode.write);
  for (var no = 1; no < 32; no++) {
    handle2.writeByteSync(no);
  }
  handle2.closeSync();
  expect(isBinary(file3.path), isTrue);
});
  • final base = path.join(Directory.systemTemp.path, 'helper'); Damit der Test plattformunabhängig ist, also unter Linux und Windows funktioniert, fragen wir mit Directory.systemTemp.path den Namen des temporären Verzeichnisses ab, unter Linux ist das '/tmp', unter Windows c:\temp oder ähnliches. Dieses Verzeichnis wird mit der Funktion join() mit dem Unterverzeichnis namens helper ergänzt, so dass in base dann unter Linux /tmp/helper und unter Windows c:\temp\helper steht.
  • final file1 = path.join(base, 'notBinary.01'); mit der Funktion join aus dem Paket path setzen wir plattformunabhängig einen Dateinamen aus Verzeichnis und Namen zusammen.
  • writeString(file1, string: 'abc\r\n\t\f'); schreibt einen normalen Text in eine Datei (siehe Datei helper.dart).
  • expect(isBinary(file1), isFalse); Eine normale Textdatei ist nicht binär, wir erwarten als Ergebnis also false.
  • final handle1 = file2.openSync(mode: FileMode.write); Damit öffnen wir eine Datei zum Schreiben.
  • handle1.writeByteSync(0); Wir schreiben das Byte 0 in die Datei, danach noch ein weiteres Byte mit der Nummer 33 (das ist das Ausrufezeichen).
  • handle1.closeSync(); Wer eine Datei öffnet, muss sie auch schließen, sonst werden Resourcen nicht freigegeben.
  • Jetzt habe wir eine binäre Datei, die wir testen können. expect(isBinary(file2.path), isTrue);
  • Nach unserer Definition liegt auch dann eine Binärdatei vor, wenn mehr als 25% der Zeichen Kontrollzeichen sind.
  • for (var no = 1; no < 32; no++) Mit dieser Schleife schreiben wir 30 Zeichen, die meisten Kontrollzeichen, in die zweite Datei.