*/

package org.gradle.api.internal.provider;

import org.gradle.internal.exceptions.Contextual;

@Contextual
public class MissingValueException extends IllegalStateException {
    public MissingValueException(String message) {
        super(message);
    }

    public MissingValueException(String message, Throwable cause) {
        super(message, cause);
    }

 * limitations under the License.
 */

package org.gradle.api.internal.file

import org.gradle.api.file.Directory
import org.gradle.api.internal.provider.MissingValueException
import org.gradle.api.internal.provider.PropertyInternal
import org.gradle.internal.state.ManagedFactory

class DirectoryPropertyTest extends FileSystemPropertySpec<Directory> {
    @Override

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.util.internal

import org.gradle.api.internal.provider.MissingValueException
import org.gradle.api.internal.provider.Providers
import spock.lang.Specification

class DeferredUtilTest extends Specification {

    def "unpacks #description to null"() {
        expect:

        if (!missingProviderErrors.isEmpty()) {
            throw new ProjectConfigurationException("Credentials required for this build could not be resolved.",
                missingProviderErrors.stream().map(MissingValueException::new).collect(Collectors.toList()));
        }
    }

    private abstract class CredentialsProvider<T extends Credentials> implements Callable<T> {
        private final String identity;

        def provider = factory.provide(PasswordCredentials, 'myService')

        when:
        provider.get()

        then:
        def e = thrown(MissingValueException)
        e.message.contains("The following Gradle properties are missing for 'myService' credentials:")
        e.message.contains("- myServiceUsername")
        e.message.contains("- myServicePassword")
    }

    protected Value<? extends T> calculateOwnPresentValue() {
        Value<? extends T> value = calculateOwnValue(ValueConsumer.IgnoreUnsafeRead);
        if (value.isMissing()) {
            throw new MissingValueException(cannotQueryValueOf(value));
        }

        return value;
    }

    @Override
    public boolean isPresent() {
        return calculatePresence(ValueConsumer.IgnoreUnsafeRead);
    }