class DoShareEnumValidation {

        static Stream<Arguments> invalidShareEnumCases() {
            return Stream.of(
                    // Missing trailing slash -> should complain about directory ending
                    Arguments.of("smb://server/share", "/share", true),
                    // Not a server root -> invalid list operation
                    Arguments.of("smb://server/share/", "/share/", false));
        }

/**
 * Defines the contract for parsing Maven command-line arguments and creating an execution or invoker requests.
 *
 * @since 4.0.0
 */
@Experimental
public interface Parser {
    /**
     * Parses the given ParserRequest to create an {@link InvokerRequest}.
     * This method does interpret tool arguments.
     *
     * @param parserRequest the request containing all necessary information for parsing

    checkNotNull(arguments);
    checkArgument(rawType.getEnclosingClass() != null, "Owner type for unenclosed %s", rawType);
    return new ParameterizedTypeImpl(ownerType, rawType, arguments);
  }

  /** Returns a type where {@code rawType} is parameterized by {@code arguments}. */
  static ParameterizedType newParameterizedType(Class<?> rawType, Type... arguments) {
    return new ParameterizedTypeImpl(

                isJavaClass -> p.copy(
                    type = toKotlinClass(),
                    asArgument = "${p.asArgument}.java"
                )

                isKotlinArray && typeArguments.single().isJavaClass -> p.copy(
                    type = toArrayOfKotlinClasses(),
                    asArgument = "${p.asArgument}.map { it.java }.toTypedArray()"
                )

    checkNotNull(arguments);
    checkArgument(rawType.getEnclosingClass() != null, "Owner type for unenclosed %s", rawType);
    return new ParameterizedTypeImpl(ownerType, rawType, arguments);
  }

  /** Returns a type where {@code rawType} is parameterized by {@code arguments}. */
  static ParameterizedType newParameterizedType(Class<?> rawType, Type... arguments) {
    return new ParameterizedTypeImpl(

            assertEquals(expectedSize, context.size());
        }

        static Stream<Arguments> provideSizeTestCases() {
            return Stream.of(Arguments.of(0, 0, 4), Arguments.of(1, 0, 6), Arguments.of(0, 1, 5), Arguments.of(1, 1, 7),
                    Arguments.of(5, 10, 24), Arguments.of(10, 20, 44), Arguments.of(20, 32, 76));
        }
    }

    @Nested
    @DisplayName("Round-trip Tests")

{* ../../docs_src/background_tasks/tutorial001.py hl[14] *}

`.add_task()` reçoit comme arguments :

* Une fonction de tâche à exécuter en arrière-plan (`write_notification`).
* Les arguments positionnels à passer à la fonction de tâche dans l'ordre (`email`).
* Les arguments nommés à passer à la fonction de tâche (`message="some notification"`).

## Injection de dépendances

    "joined": "2018-11-30",
}

my_second_user: User = User(**second_user_data)
```

/// info

`**second_user_data` means:

Pass the keys and values of the `second_user_data` dict directly as key-value arguments, equivalent to: `User(id=4, name="Mary", joined="2018-11-30")`

///

### Editor support { #editor-support }

{* ../../docs_src/background_tasks/tutorial001_py39.py hl[14] *}

`.add_task()` receives as arguments:

* A task function to be run in the background (`write_notification`).
* Any sequence of arguments that should be passed to the task function in order (`email`).
* Any keyword arguments that should be passed to the task function (`message="some notification"`).

## Dependency Injection { #dependency-injection }

     * @param args the array of objects to be passed as arguments to the constructor invocation
     * @return a new object created by invoking the constructor
     * @throws InstantiationRuntimeException if the class declaring the constructor is abstract
     * @throws IllegalAccessRuntimeException if the number of actual and formal parameters differ, if primitive arguments cannot be converted, or if the class is related to enums