return "Unknown";
  }
  switch (action.value_or(ConversionTarget::LegalizationAction::Legal)) {
    case ConversionTarget::LegalizationAction::Legal:
      return "Legal";
    case ConversionTarget::LegalizationAction::Dynamic:
      return "Dynamic";
    case ConversionTarget::LegalizationAction::Illegal:
      return "Illegal";
    default:
      return "Invalid";
  }
}

- Method create(java.lang.String) is not a valid rule method: The declared model element path '!!!!' used for parameter 1 is not a valid path: Model element name '!!!!' has illegal first character '!' (names must start with an ASCII letter or underscore)."""
    }

    static class MutationRules extends RuleSource {
        @Mutate
        static void mutate1(List<String> strings) {
        }

		{[]string{
			"I4======N4======",
		}, "illegal base32 data at input byte 2"},

		{[]string{
			"I4======",
			"N4======",
		}, "illegal base32 data at input byte 0"},

		{[]string{
			"I4======",
			"========",
		}, "illegal base32 data at input byte 0"},

		{[]string{
			"I4I4I4I4",
			"I4======",
			"I4======",
		}, "illegal base32 data at input byte 0"},
	}

        for (V v : src) {
            if (failOnNull && v == null) {
                throw new IllegalArgumentException("Illegal null value provided in this collection: " + src);
            }
            dest.add(v);
        }
        return dest;
    }

		e.SameSite = "SameSite=Strict"
	case http.SameSiteLaxMode:
		e.SameSite = "SameSite=Lax"
	}

	return e, false, nil
}

var (
	errIllegalDomain   = errors.New("cookiejar: illegal cookie domain attribute")
	errMalformedDomain = errors.New("cookiejar: malformed cookie domain attribute")
)

// endOfTime is the time when session (non-persistent) cookies expire.

        for (V v : src) {
            if (failOnNull && v == null) {
                throw new IllegalArgumentException("Illegal null value provided in this collection: " + src);
            }
            dest.add(v);
        }
        return dest;
    }

        failure.assertHasDescription("Error loading encryption key from GRADLE_ENCRYPTION_KEY environment variable")
        failure.assertHasCause("Illegal base64 character ${Integer.toHexString((int) invalidBase64Char)}")
    }

    def "build fails if key is provided via env var but not long enough"() {
        given:

    }

    @Override
    public WorkerProcessBuilder applicationClasspath(Iterable<File> files) {
        for (File file : files) {
            if (file == null) {
                throw new IllegalArgumentException("Illegal null value provided in this collection: " + files);
            }
            if (isEntryValid(file)) {
                applicationClasspath.add(file);
            }
        }
        return this;
    }

	{25, "ENOTTY", "inappropriate ioctl for device"},
	{26, "ETXTBSY", "text file busy"},
	{27, "EFBIG", "file too large"},
	{28, "ENOSPC", "no space left on device"},
	{29, "ESPIPE", "illegal seek"},
	{30, "EROFS", "read-only file system"},
	{31, "EMLINK", "too many links"},
	{32, "EPIPE", "broken pipe"},
	{33, "EDOM", "numerical argument out of domain"},
	{34, "ERANGE", "numerical result out of range"},

        val convertedText: Any? = when (type) {
            INTEGER_CONSTANT, INTEGER_LITERAL -> when {
                hasIllegalUnderscore(text, type) -> return reportIncorrectConstant("illegal underscore")
                else -> parseNumericLiteral(text, INTEGER_CONSTANT)
            }
            BOOLEAN_CONSTANT -> parseBoolean(text)
            else -> null
        }

        when (type) {