Comment assertThat Chaîne n'est pas vide

Affirme qu'une string n'est pas vide dans junit peut être effectué de la façon suivante:

 assertTrue(!string.isEmpty());
 assertFalse(string.isEmpty());
 assertThat(string.toCharArray(), is(not(emptyArray())); //(although this didn't compile)

Ma question est: est-il un meilleur moyen de vérifier cela - quelque chose comme:

assertThat(string, is(not(empty()))?

Il y a une correspondance pour ces opérations de la chaîne: IsEmptyString
Une autre alternative: assertThat(string.isEmpty(), is(false))

OriginalL'auteur Armine | 2017-05-20

35

Dans hamcrest 1.3 vous pouvez à l'aide de Les allumettes#isEmptyString :
```
assertThat(string, not(isEmptyString()));
```
Dans hamcrest 2.0, vous pouvez à l'aide de Les allumettes#emptyString :
```
assertThat(string, is(not(emptyString())));
```
Mise à JOUR Avis que : "Maven central a certains artefacts extra appelé java-hamcrest et hamcrest-java, avec une version 2.0.0.0. Merci de ne pas les utiliser, car ils sont l'échec de l'effort de reconditionnement les différents pots." source : hamcrest.org/JavaHamcrest/distributables

salut, monsieur. Merci pour vos commentaires. En fait c'est la voie courte de la vôtre. ^_^
Ouais, mais le tien est mieux (ou au moins, c'est ce que j'avais réellement l'utiliser, maintenant que je sais qu'il existe).
oui, il peut faire le test de code plus lisible (on peut lire à l'expressivité de test comme un article).
Bonne réponse, mais méfiez-vous que les déclarations retourne true lorsque la Chaîne est nulle.. Selon vos spécifications, vous voudrez peut-être ajouter CoreMatchers.notNullValue() à votre test.
oui, monsieur. mais la question est de vérifier si la Chaîne est vide plutôt que null ou vide. pour qu'il y sont liées les allumettes, e.g: isEmptyOrNullString() en 1.3 ou emptyOrNullString() en 2.0.

OriginalL'auteur holi-java
3

J'utiliserais assertThat(string, is(not(equalTo("")))). Contrairement à d'autres approches qui impliquent vérifier le résultat de la chaîne de .length() ou .isEmpty() méthodes, cela va vous montrer que la chaîne de caractères contenu dans le message d'erreur lorsque le test échoue.

(Edit: en Fait, non, je ne le ferais pas. J'aimerais utiliser le emptyString() ou isEmptyString() matcher comme expliqué dans holi-java réponse. Upvote, pas celui-ci.)

OriginalL'auteur Wyzard
3

Vous pouvez utiliser JUnit propre assertNotEquals affirmation:
```
Assert.assertNotEquals( "", string );
```
OriginalL'auteur Stefan Birkner
2

Envisager d'utiliser Apache StringUtils.isNotEmpty() méthode, qui est un null-coffre-fort à la vérification d'une chaîne vide.
```
assertTrue(StringUtils.isNotEmpty(str));
```
OriginalL'auteur entpnerd
1

Écrire votre propre TestHelper classe où vous pouvez recueillir des méthodes personnalisées pour les assertions, par exemple
```
 public static void assertEmpty(String input) {...}
```
C'est quelque chose comme ce qui peut être mis en œuvre en moi. Est-ce à dire, il n'y a pas d'autre moyen à l'aide de Mathcers?
C'est juste un conseil. La plus grande de votre application grossit, il est utile d'avoir personnalisé les affirmations et les méthodes d'assistance qui prennent en charge les tests de votre propre logique d'entreprise. Par exemple, au lieu de tester assertTrue(password.length>6) vous pourriez avoir un assertPasswordOk(password) méthode qui vérifie tous les critères pour un mot de passe valide.

OriginalL'auteur Matt
1

Ce que vous pouvez également utiliser la bibliothèque appelée AssertJ qui offre une plus grande couramment assertions dans votre code. Vérification peut être effectuée avec de l'élégant:

assertThat(myString).isNotEmpty();

OriginalL'auteur Tomasz Bawor
1

Si vous utilisez déjà communes-lang3 vous pouvez le faire, qui vérifie également pour les nuls et les espaces:
```
assertTrue(StringUtils.isNotBlank(string));
```
Comme décrit dans leur documentation javadoc:

isNotBlank : Vérifie si un CharSequence n'est pas vide (""), non nul, et pas seulement les espaces.

Excellente solution trop!!! Je vais prendre cela en compte dans les cas suivants.
Que l'OP n'a pas mentionné le "vide" en cas, entpnerd réponse est plus pertinente.

OriginalL'auteur Russ Jackson
1

Vous pouvez utiliser le Google Goyave Bibliothèque méthode Les chaînes de caractères.isNullOrEmpty

De la JavaDoc

public static boolean isNullOrEmpty(@Nullable String String)

Retourne true si la chaîne est null ou une chaîne vide.

Envisager de normaliser votre chaîne de références avec nullToEmpty(java.lang.Chaîne de caractères).
Si vous le faites, vous pouvez utiliser des chaînes de caractères.isEmpty() à la place de cette méthode, et
vous n'aurez pas besoin spécial null-sûr les formes de méthodes comme
Chaîne de caractères.toUpperCase(java.util.Paramètres régionaux). Ou, si vous le souhaitez
normaliser "dans l'autre sens," la conversion des chaînes vides à null,
vous pouvez utiliser emptyToNull(java.lang.Chaîne de caractères).

Paramètres:

string - chaîne de référence pour vérifier

Retourne:

vrai si la chaîne est nulle ou est la chaîne vide

Merci pour la réponse. mais ma question n'est pas lié, pour que la chaîne peut être nulle, mais le moyen d'affirmer que la chaîne n'est pas vide (j'ai couvert la possibilité de valeur null part, il est hors de la portée de cette question).

OriginalL'auteur Saikat
0

Ce que vous voulez dire, c'est la taille de votre chaîne.
```
assertThat("String is empty",
       string.length(),
       greaterThan(0));
```
Si la Chaîne est nulle, il serait jeter NullPointerException.

OriginalL'auteur Simulant

Vous devez vous connecter pour publier un commentaire.