Comparer des chaînes

Résumé

Nom interne : CompareStrings
Catégorie : Outils
Objectif : Comparer deux valeurs textuelles avec un opérateur de comparaison configurable et retourner un résultat booléen.
Type de tâche : Conditionnelle

Compatibilité

Version minimale AndroMate : 1.1.0
Version maximale AndroMate : 1.1.0
Android minimum : Android 13 (API 33)
Android maximum testé : Android 16 (API 36)
Constructeurs supportés :
- ✅ Samsung (One UI 6.x / 7.x / 8.x)
- ✅ Google Pixel (Android Stock)
- ⚠️ Autres constructeurs — non testés
Permissions requises :
- Aucune

Description détaillée

La tâche Comparer des chaînes compare deux valeurs textuelles (var_x et var_y) à l'aide d'un opérateur de comparaison spécifié. Elle retourne true ou false et dirige l'exécution vers la branche correspondante du graphe de workflow.

var_x et var_y supportent les références $variable_workflow — elles sont résolues à l'exécution avant que la comparaison ne soit effectuée.

Opérateurs de comparaison

Le champ compare_type détermine comment var_x est comparé à var_y.

Valeur `compare_type`	Opérateur	Description
`"Equal"`	`==`	`var_x` est exactement égal à `var_y` (sensible à la casse)
`"Equal ignore case"`	`==` (insensible à la casse)	`var_x` égale `var_y`, sans tenir compte de la casse
`"Contains"`	`contains`	`var_x` contient la sous-chaîne `var_y`
`"Start with"`	`startsWith`	`var_x` commence par le préfixe `var_y`

Paramètres d'entrée

Paramètre	Type	Obligatoire	Valeurs possibles	Compatibilité Android	Compatibilité AndroMate	Défaut
`var_x`	String	Oui	Toute chaîne — supporte les références `$variable`	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`""`
`var_y`	String	Oui	Toute chaîne — supporte les références `$variable`	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`""`
`compare_type`	String	Oui	`"Equal"` / `"Equal ignore case"` / `"Contains"` / `"Start with"`	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`""`

Paramètres de sortie

Cette tâche est une tâche conditionnelle — elle ne produit aucune variable de sortie. Le résultat booléen contrôle la branche d'exécution :

Résultat	Condition	Branche empruntée
`true`	La condition de comparaison est satisfaite	Lien `"true"`
`false`	La condition de comparaison n'est pas satisfaite	Lien `"false"`

Exceptions

Code	Nom de l'exception	Description
`COMPARE-VAR-001`	Type de comparaison non supporté	La valeur fournie dans `compare_type` ne correspond à aucun opérateur supporté. Valeurs acceptées : `"Equal"`, `"Equal ignore case"`, `"Contains"`, `"Start with"`.

Diagramme d'exécution

Le diagramme suivant illustre l'implémentation réelle basée sur le code Android :

flowchart TD
    Start([Démarrer CompareStrings]) --> ResolveX[🔄 Résoudre var_x\ndepuis le contexte workflow]
    ResolveX --> ResolveY[🔄 Résoudre var_y\ndepuis le contexte workflow]
    ResolveY --> ParseType{Parser compare_type}

    ParseType -->|"Equal"| EqualOp["var_x.equals(var_y)"]
    ParseType -->|"Equal ignore case"| IgnoreCaseOp["var_x.equalsIgnoreCase(var_y)"]
    ParseType -->|"Contains"| ContainsOp["var_x.contains(var_y)"]
    ParseType -->|"Start with"| StartWithOp["var_x.startsWith(var_y)"]
    ParseType -->|Inconnu| E1[❌ COMPARE-VAR-001]

    EqualOp --> Result{résultat booléen}
    IgnoreCaseOp --> Result
    ContainsOp --> Result
    StartWithOp --> Result

    Result -->|true| True([✅ true → suivre la branche true])
    Result -->|false| False([✅ false → suivre la branche false])

    E1 --> Error([❌ Exception])

    style Start fill:#e3f2fd
    style True fill:#c8e6c9
    style False fill:#ffe0e0
    style Error fill:#ffcdd2
    style E1 fill:#ffcdd2
    style ResolveX fill:#fff9c4
    style ResolveY fill:#fff9c4
    style EqualOp fill:#f3e5f5
    style IgnoreCaseOp fill:#f3e5f5
    style ContainsOp fill:#f3e5f5
    style StartWithOp fill:#f3e5f5

Comment ça fonctionne :

Résoudre les opérandes : var_x et var_y sont résolus depuis le contexte workflow (remplacement des références $variable)
Parser l'opérateur : compare_type est comparé aux valeurs string supportées
Exécuter la comparaison : la méthode Java String appropriée est appelée
Retourner le résultat : true ou false — le moteur workflow route vers la branche correspondante

Exemples de code

Exemple 1 — Vérification d'égalité exacte

{
  "CompareStrings": [
    {
      "id": "1",
      "title": "Vérifier le statut",
      "var_x": "$http_status",
      "var_y": "200",
      "compare_type": "Equal"
    }
  ]
}

Retourne true si $http_status est exactement "200".

Exemple 2 — Vérification insensible à la casse

{
  "CompareStrings": [
    {
      "id": "2",
      "title": "Vérifier le mot-clé (insensible à la casse)",
      "var_x": "$response_body",
      "var_y": "success",
      "compare_type": "Equal ignore case"
    }
  ]
}

Retourne true si $response_body est égal à "success" quelle que soit la casse.

Exemple 3 — Vérification de sous-chaîne

{
  "CompareStrings": [
    {
      "id": "3",
      "title": "Vérifier un mot-clé d'erreur",
      "var_x": "$cmd_output",
      "var_y": "unreachable",
      "compare_type": "Contains"
    }
  ]
}

Retourne true si $cmd_output contient le mot "unreachable".

Exemple 4 — Vérification de préfixe

{
  "CompareStrings": [
    {
      "id": "4",
      "title": "Vérifier le préfixe",
      "var_x": "$device_model",
      "var_y": "Samsung",
      "compare_type": "Start with"
    }
  ]
}

Retourne true si $device_model commence par "Samsung".

Détails des paramètres d'entrée

1. Paramètre d'entrée : `var_x`

L'opérande chaîne de gauche de la comparaison. Supporte les références $variable_workflow — résolues à l'exécution avant la comparaison.

Défaut : "" (chaîne vide)
Supporte les variables : Oui

2. Paramètre d'entrée : `var_y`

L'opérande chaîne de droite de la comparaison. Supporte les références $variable_workflow — résolues à l'exécution avant la comparaison.

Défaut : "" (chaîne vide)
Supporte les variables : Oui

3. Paramètre d'entrée : `compare_type`

Détermine quelle méthode de comparaison de chaînes est appliquée. Doit correspondre exactement à l'une des valeurs supportées (insensible à la casse).

Valeur	Méthode Java	Comportement
`"Equal"`	`var_x.equals(var_y)`	Égalité exacte sensible à la casse
`"Equal ignore case"`	`var_x.equalsIgnoreCase(var_y)`	Égalité insensible à la casse
`"Contains"`	`var_x.contains(var_y)`	`var_x` contient `var_y` comme sous-chaîne
`"Start with"`	`var_x.startsWith(var_y)`	`var_x` commence par `var_y`

Défaut : "" — déclenche COMPARE-VAR-001 si non renseigné

Exemple JSON complet

{
  "CompareStrings": [
    {
      "id": "1",
      "title": "Vérifier si la réponse contient succès",
      "var_x": "$response_body",
      "var_y": "success",
      "compare_type": "Contains"
    }
  ]
}