get() = code in 200..299

fun Response.commonHeaders(name: String): List<String> = headers.values(name)

@JvmOverloads
fun Response.commonHeader(
  name: String,
  defaultValue: String?,
): String? = headers[name] ?: defaultValue

@Throws(IOException::class)
fun Response.commonPeekBody(byteCount: Long): ResponseBody {
  val peeked = body.source().peek()
  val buffer = Buffer()
  peeked.request(byteCount)

import java.io.File;

public interface ProviderConnectionParameters {
    boolean getVerboseLogging();

    String getConsumerVersion();

    @Nullable
    File getGradleUserHomeDir(File defaultValue);

   * otherwise, returns {@code defaultValue}.
   *
   * <p>In an undirected graph, this is equal to {@code edgeValueOrDefault(nodeV, nodeU,
   * defaultValue)}.
   *
   * @throws IllegalArgumentException if {@code nodeU} or {@code nodeV} is not an element of this
   *     graph
   */
  @CheckForNull
  V edgeValueOrDefault(N nodeU, N nodeV, @CheckForNull V defaultValue);

  /**

        return parent.hashCode();
    }

    @Override
    public V getOrDefault(final Object key, final V defaultValue) {
        final V value = parent.get(key);
        if (value != null) {
            return value;
        }
        return parent.getOrDefault(toCamelCase(key), defaultValue);
    }

    @Override
    public void forEach(final BiConsumer<? super K, ? super V> action) {

			},
		},
		ReflectValue: reflect.ValueOf(dest),
		Dest:         dest,
	}

	stmt.Schema = s

	values := ConvertToCreateValues(stmt)
	expected := clause.Values{
		// column has value + defaultValue column has value (which should have a stable order)
		Columns: []clause.Column{{Name: "name"}, {Name: "email"}, {Name: "age"}, {Name: "id"}},
		Values: [][]interface{}{
			{"alice", "email", 18, 1},
			{"bob", "email", 19, 2},

		ProbeTimeout:            constants.DefaultProbeTimeout,
		OwnerGroupsInclude:      constants.OwnerGroupsInclude.DefaultValue,
		OwnerGroupsExclude:      constants.OwnerGroupsExclude.DefaultValue,
		HostIPv4LoopbackCidr:    constants.HostIPv4LoopbackCidr.DefaultValue,
	}
}

// Command line options
// nolint: maligned
type Config struct {
	ProxyPort               string        `json:"PROXY_PORT"`

		return bytesEncoder(nil), nil
	}

	if params.optional && params.defaultValue != nil && canHaveDefaultValue(v.Kind()) {
		defaultValue := reflect.New(v.Type()).Elem()
		defaultValue.SetInt(*params.defaultValue)

		if reflect.DeepEqual(v.Interface(), defaultValue.Interface()) {
			return bytesEncoder(nil), nil
		}
	}

        def result = serialize(event, serializer)
        result instanceof BooleanQuestionPromptEvent
        result.question == 'prompt'
        !result.defaultValue
        result.timestamp == 123
    }

    def "can serialize int question prompt event"() {
        expect:
        def event = new IntQuestionPromptEvent(123, 'prompt', 1, 2)

        if (value == null) {
            value = System.getProperty(option.getSystemPropertyName());
        }
        if (value == null) {
            return Option.Value.defaultValue(option.getDefaultValue());
        } else {
            return Option.Value.value(option.convert(value));
        }
    }

	columnType, err := findColumnType(tableName, "content")
	AssertEqual(t, err, nil)

	defVal, ok := columnType.DefaultValue()
	AssertEqual(t, defVal, "null")
	AssertEqual(t, ok, true)

	columnType2, err := findColumnType(tableName, "active")
	AssertEqual(t, err, nil)

	defVal, ok = columnType2.DefaultValue()
	bv, _ := strconv.ParseBool(defVal)
	AssertEqual(t, bv, false)
	AssertEqual(t, ok, true)