

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erstellen Sie Konfigurationsdateien für die IDT-Testsuite
<a name="idt-json-config"></a>

In diesem Abschnitt werden die Formate beschrieben, in denen Sie Konfigurationsdateien erstellen, die Sie beim Schreiben einer benutzerdefinierten Testsuite einbeziehen.

**Erforderliche Konfigurationsdateien**

**`suite.json`**  
Enthält Informationen über die Testsuite. Siehe [Konfigurieren Sie suite.json](#suite-json).

**`group.json`**  
Enthält Informationen über eine Testgruppe. Sie müssen für jede Testgruppe in Ihrer Testsuite eine `group.json` Datei erstellen. Siehe [Konfigurieren Sie group.json](#group-json).

**`test.json`**  
Enthält Informationen zu einem Testfall. Sie müssen für jeden Testfall in Ihrer Testsuite eine `test.json` Datei erstellen. Siehe [Konfigurieren Sie test.json](#test-json).

**Optionale Konfigurationsdateien**

**`test_orchestrator.yaml` oder `state_machine.json`**  
Definiert, wie Tests ausgeführt werden, wenn IDT die Testsuite ausführt. SSe [Konfigurieren Sie test\$1orchestrator.yaml](#test-orchestrator-config).  
Ab IDT v4.5.2 verwenden Sie die `test_orchestrator.yaml` Datei, um den Test-Workflow zu definieren. In früheren Versionen von IDT verwenden Sie die Datei. `state_machine.json` Informationen zur Zustandsmaschine finden Sie unter[Konfigurieren Sie die IDT-Zustandsmaschine](idt-state-machine.md).

**`userdata_schema.json`**  
Definiert das Schema für die [`userdata.json`Datei](set-config-custom.md#userdata-config-custom), die Testläufer in ihre Einstellungskonfiguration aufnehmen können. Die `userdata.json` Datei wird für alle zusätzlichen Konfigurationsinformationen verwendet, die für die Ausführung des Tests erforderlich sind, aber nicht in der `device.json` Datei enthalten sind. Siehe [Konfigurieren Sie userdata\$1schema.json](#userdata-schema-json).

Die Konfigurationsdateien werden `<custom-test-suite-folder>` wie hier gezeigt in Ihrem abgelegt.

```
<custom-test-suite-folder>
└── suite
    ├── suite.json
    ├── test_orchestrator.yaml
    ├── userdata_schema.json
    ├── <test-group-folder>
        ├── group.json
        ├── <test-case-folder>
            └── test.json
```

## Konfigurieren Sie suite.json
<a name="suite-json"></a>

Die `suite.json` Datei legt Umgebungsvariablen fest und bestimmt, ob Benutzerdaten für die Ausführung der Testsuite erforderlich sind. Verwenden Sie die folgende Vorlage, um Ihre `<custom-test-suite-folder>/suite/suite.json` Datei zu konfigurieren: 

```
{
    "id": "<suite-name>_<suite-version>",
    "title": "<suite-title>",
    "details": "<suite-details>",
    "userDataRequired": true | false,
    "environmentVariables": [
        {
            "key": "<name>",
            "value": "<value>",
        },
        ...
        {
            "key": "<name>",
            "value": "<value>",
        }
    ]
}
```

Nachfolgend sind alle Pflichtfelder beschrieben:

**`id`**  
Eine eindeutige benutzerdefinierte ID für die Testsuite. Der Wert von `id` muss mit dem Namen des Testsuite-Ordners übereinstimmen, in dem sich die `suite.json` Datei befindet. Der Name der Suite und die Suite-Version müssen außerdem die folgenden Anforderungen erfüllen:   
+ `<suite-name>`darf keine Unterstriche enthalten.
+ `<suite-version>`wird bezeichnet als`x.x.x`, wo `x` ist eine Zahl.
Die ID wird in IDT-generierten Testberichten angezeigt.

**`title`**  
Ein benutzerdefinierter Name für das Produkt oder die Funktion, das von dieser Testsuite getestet wird. Der Name wird in der IDT-CLI für Testläufer angezeigt.

**`details`**  
Eine kurze Beschreibung des Zwecks der Testsuite.

**`userDataRequired`**  
Definiert, ob Testläufer benutzerdefinierte Informationen in eine `userdata.json` Datei aufnehmen müssen. Wenn Sie diesen Wert auf setzen`true`, müssen Sie die [`userdata_schema.json`Datei](#userdata-schema-json) auch in Ihren Testsuite-Ordner aufnehmen.

**`environmentVariables`**  
Optional. Ein Array von Umgebungsvariablen, die für diese Testsuite festgelegt werden sollen.    
**`environmentVariables.key`**  
Der Name der Umgebungsvariable.  
**`environmentVariables.value`**  
Der Wert der Umgebungsvariable.

## Konfigurieren Sie group.json
<a name="group-json"></a>

Die `group.json` Datei definiert, ob eine Testgruppe erforderlich oder optional ist. Verwenden Sie die folgende Vorlage, um Ihre `<custom-test-suite-folder>/suite/<test-group>/group.json` Datei zu konfigurieren: 

```
{
    "id": "<group-id>",
    "title": "<group-title>",
    "details": "<group-details>",
    "optional": true | false,
}
```

Nachfolgend sind alle Pflichtfelder beschrieben:

**`id`**  
Eine eindeutige benutzerdefinierte ID für die Testgruppe. Der Wert von `id` muss mit dem Namen des Testgruppenordners übereinstimmen, in dem sich die `group.json` Datei befindet, und darf keine Unterstriche () `_` enthalten. Die ID wird in IDT-generierten Testberichten verwendet.

**`title`**  
Ein beschreibender Name für die Testgruppe. Der Name wird in der IDT-CLI für Testläufer angezeigt.

**`details`**  
Eine kurze Beschreibung des Zwecks der Testgruppe.

**`optional`**  
Optional. Stellen Sie diese Option ein`true`, um diese Testgruppe als optionale Gruppe anzuzeigen, nachdem IDT die Ausführung der erforderlichen Tests abgeschlossen hat. Der Standardwert ist `false`.

## Konfigurieren Sie test.json
<a name="test-json"></a>

Die `test.json` Datei bestimmt die ausführbaren Testfalldateien und die Umgebungsvariablen, die von einem Testfall verwendet werden. Weitere Hinweise zum Erstellen von ausführbaren Testfalldateien finden Sie unter. [Erstellen Sie eine ausführbare IDT-Testfalldatei](test-executables.md)

Verwenden Sie die folgende Vorlage, um Ihre `<custom-test-suite-folder>/suite/<test-group>/<test-case>/test.json` Datei zu konfigurieren: 

```
{
    "id": "<test-id>",
    "title": "<test-title>",
    "details": "<test-details>",
    "requireDUT": true | false,
    "requiredResources": [
        {
            "name": "<resource-name>",
            "features": [
                {
                    "name": "<feature-name>",
                    "version": "<feature-version>",
                    "jobSlots": <job-slots>
                }
            ]
        }
    ],
    "execution": {
        "timeout": <timeout>,
        "mac": {
            "cmd": "/path/to/executable",
            "args": [
                "<argument>"
            ],
        },
        "linux": {
            "cmd": "/path/to/executable",
            "args": [
                "<argument>"
            ],
        },
        "win": {
            "cmd": "/path/to/executable",
            "args": [
                "<argument>"
            ]
        }
    },
    "environmentVariables": [
        {
            "key": "<name>",
            "value": "<value>",
        }
    ]
}
```

Nachfolgend sind alle Pflichtfelder beschrieben:

**`id`**  
Eine eindeutige benutzerdefinierte ID für den Testfall. Der Wert von `id` muss mit dem Namen des Testfallordners übereinstimmen, in dem sich die `test.json` Datei befindet, und darf keine Unterstriche () `_` enthalten. Die ID wird in IDT-generierten Testberichten verwendet.

**`title`**  
Ein beschreibender Name für den Testfall. Der Name wird in der IDT-CLI für Testläufer angezeigt.

**`details`**  
Eine kurze Beschreibung des Zwecks des Testfalls.

**`requireDUT`**  
Optional. `true`Ist auf eingestellt, wenn ein Gerät für die Ausführung dieses Tests erforderlich ist, andernfalls auf`false`. Der Standardwert ist `true`. Testläufer konfigurieren die Geräte, mit denen sie den Test ausführen, in ihrer `device.json` Datei.

**`requiredResources`**  
Optional. Ein Array, das Informationen über Ressourcengeräte bereitstellt, die für die Ausführung dieses Tests benötigt werden.     
**`requiredResources.name`**  
Der eindeutige Name, der dem Ressourcengerät gegeben werden soll, wenn dieser Test ausgeführt wird.  
**`requiredResources.features`**  
Eine Reihe von benutzerdefinierten Funktionen für Ressourcengeräte.     
**`requiredResources.features.name`**  
Der Name der Funktion. Die Gerätefunktion, für die Sie dieses Gerät verwenden möchten. Dieser Name wird mit dem Funktionsnamen abgeglichen, den der Test-Runner in der `resource.json` Datei angegeben hat.  
**`requiredResources.features.version`**  
Optional. Die Version der Funktion. Dieser Wert wird mit der vom Test-Runner in der `resource.json` Datei bereitgestellten Feature-Version verglichen. Wenn keine Version bereitgestellt wird, wird die Funktion nicht überprüft. Wenn für die Funktion keine Versionsnummer erforderlich ist, lassen Sie dieses Feld leer.  
**`requiredResources.features.jobSlots`**  
Optional. Die Anzahl der gleichzeitigen Tests, die diese Funktion unterstützen kann. Der Standardwert ist `1`. Wenn Sie möchten, dass IDT unterschiedliche Geräte für einzelne Funktionen verwendet, empfehlen wir Ihnen, diesen Wert auf `1` festzulegen.

**`execution.timeout`**  
Die Zeit (in Millisekunden), die IDT wartet, bis der Test abgeschlossen ist. Weitere Informationen zum Einstellen dieses Werts finden Sie unter. [Erstellen Sie eine ausführbare IDT-Testfalldatei](test-executables.md)

**`execution.os`**  
Die ausführbaren Testfalldateien, die auf dem Betriebssystem des Host-Computers ausgeführt werden sollen, basieren auf dem Betriebssystem, auf dem IDT ausgeführt wird. Unterstützte Werte sind `linux`, `mac` und `win`.     
**`execution.os.cmd`**  
Der Pfad zu der ausführbaren Testfalldatei, die Sie für das angegebene Betriebssystem ausführen möchten. Dieser Speicherort muss sich im Systempfad befinden.  
**`execution.os.args`**  
Optional. Die Argumente, die zur Ausführung der ausführbaren Testfalldatei angegeben werden müssen.

**`environmentVariables`**  
Optional. Ein Array von Umgebungsvariablen, die für diesen Testfall festgelegt wurden.     
**`environmentVariables.key`**  
Der Name der Umgebungsvariable.  
**`environmentVariables.value`**  
Der Wert der Umgebungsvariable.
Wenn Sie dieselbe Umgebungsvariable in der `test.json` Datei und in der `suite.json` Datei angeben, hat der Wert in der `test.json` Datei Vorrang. 

## Konfigurieren Sie test\$1orchestrator.yaml
<a name="test-orchestrator-config"></a>

Ein Testorchestrator ist ein Konstrukt, das den Ausführungsablauf der Testsuite steuert. Er bestimmt den Startstatus einer Testsuite, verwaltet Zustandsübergänge auf der Grundlage benutzerdefinierter Regeln und setzt den Übergang durch diese Zustände fort, bis der Endstatus erreicht ist. 

Wenn Ihre Testsuite keinen benutzerdefinierten Test-Orchestrator enthält, generiert IDT einen Test-Orchestrator für Sie.

Der Standard-Test-Orchestrator führt die folgenden Funktionen aus:
+ Bietet Testläufern die Möglichkeit, anstelle der gesamten Testsuite bestimmte Testgruppen auszuwählen und auszuführen.
+ Wenn keine bestimmten Testgruppen ausgewählt sind, wird jede Testgruppe in der Testsuite in zufälliger Reihenfolge ausgeführt. 
+ Generiert Berichte und druckt eine Konsolenübersicht aus, in der die Testergebnisse für jede Testgruppe und jeden Testfall angezeigt werden.

Weitere Informationen zur Funktionsweise des IDT Test Orchestrator finden Sie unter. [Konfigurieren Sie den IDT-Testorchestrator](idt-test-orchestrator.md)

## Konfigurieren Sie userdata\$1schema.json
<a name="userdata-schema-json"></a>

Die `userdata_schema.json` Datei bestimmt das Schema, in dem Testläufer Benutzerdaten bereitstellen. Benutzerdaten sind erforderlich, wenn Ihre Testsuite Informationen benötigt, die nicht in der `device.json` Datei enthalten sind. Beispielsweise benötigen Ihre Tests möglicherweise Anmeldeinformationen für Wi-Fi-Netzwerke, bestimmte offene Ports oder Zertifikate, die ein Benutzer bereitstellen muss. Diese Informationen können IDT als Eingabeparameter zur Verfügung gestellt werden`userdata`, dessen Wert eine `userdata.json` Datei ist, die Benutzer in ihrem `<device-tester-extract-location>/config` Ordner erstellen. Das Format der `userdata.json` Datei basiert auf der `userdata_schema.json` Datei, die Sie in die Testsuite aufnehmen.

Um anzugeben, dass Testläufer eine `userdata.json` Datei bereitstellen müssen:

1. Stellen Sie in der `suite.json` Datei `userDataRequired` auf ein`true`.

1. Erstellen Sie in Ihrem `<custom-test-suite-folder>` eine `userdata_schema.json` Datei.

1. Bearbeiten Sie die `userdata_schema.json` Datei, um ein gültiges [IETF-Draft v4-JSON-Schema](https://json-schema.org/specification-links#draft-4) zu erstellen.

Wenn IDT Ihre Testsuite ausführt, liest es automatisch das Schema und verwendet es, um die vom Testläufer bereitgestellte `userdata.json` Datei zu validieren. Falls gültig, ist der Inhalt der `userdata.json` Datei sowohl im [IDT-Kontext als auch im [Test-Orchestrator-Kontext](idt-test-orchestrator.md#idt-test-orchestrator-context)](idt-context.md) verfügbar.