repositories {
    ivy {
        url layout.projectDirectory.dir("repo")
    }
}

// Set up the status scheme so that "experimental" is a valid status for "org.sample" artifacts

class StatusRule implements ComponentMetadataRule {

    @Override
    void execute(ComponentMetadataContext componentMetadataContext) {
        def details = componentMetadataContext.details
        if (details.id.group == "org.sample") {

repositories {
    ivy {
        url = uri(layout.projectDirectory.dir("repo"))
    }
}

// Set up the status scheme so that "experimental" is a valid status for "org.sample" artifacts

class StatusRule : ComponentMetadataRule {

    override fun execute(componentMetadataContext: ComponentMetadataContext) {
        val details = componentMetadataContext.details
        if (details.id.group == "org.sample") {

 * limitations under the License.
 */

package org.gradle.internal.resource.transport.http;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.StatusLine;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.utils.HttpClientUtils;

import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;

        def c = repo.module('group2', 'projectC', '12-SNAPSHOT').publish().allowAll()

        and:
        buildFile.text =
"""
$repoDeclaration
configurations { compile }
class StatusRule implements ComponentMetadataRule {
    public void execute(ComponentMetadataContext context) {
            assert context.details.status == context.details.id.name == "projectA" ? "release" : "integration"

 */

package org.gradle.internal.resource.transport.http

import org.apache.http.Header
import org.apache.http.HttpEntity
import org.apache.http.HttpHeaders
import org.apache.http.StatusLine
import org.apache.http.client.methods.CloseableHttpResponse
import org.apache.http.message.BasicHeader

class HttpResponseResourceTest extends AbstractHttpClientTest {

    def sourceUrl = new URI("http://gradle.org")

		</RollingFile>
		<Rewrite name="AppFile">
			<AppenderRef ref="AppRollingFile" />
			<ErrorToWarnRewritePolicy loggers="org.apache.fontbox,org.apache.pdfbox,org.apache.poi" />
		</Rewrite>
		<RollingFile name="StatsFile" fileName="${log.file.basedir}/fess-urls.log"
			filePattern="${log.file.basedir}/fess-urls${backup.date.suffix}-%i.log.gz">
			<PatternLayout>
				<Pattern>${stats.log.pattern}</Pattern>
			</PatternLayout>
			<Policies>

import okhttp3.MediaType
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.curl.Main
import okhttp3.internal.http.StatusLine
import okio.sink

internal fun Main.commonCreateRequest(): Request {
  val request = Request.Builder()

  val requestMethod = method ?: if (data != null) "POST" else "GET"

	return readDriveStats(fmt.Sprintf("/sys/dev/block/%v:%v/stat", major, minor))
}

func readDriveStats(statsFile string) (iostats IOStats, err error) {
	stats, err := readStat(statsFile)
	if err != nil {
		return IOStats{}, err
	}
	if len(stats) < 11 {
		return IOStats{}, fmt.Errorf("found invalid format while reading %v", statsFile)
	}
	// refer https://www.kernel.org/doc/Documentation/block/stat.txt
	iostats = IOStats{

			VolumeID: volumeName,
			FSType:   "ext4",
		}
	}
	return pv
}

func getFakePersistentVolumeClaim(pvcName, volumeName, statusSize, requestSize string, uid types.UID) *v1.PersistentVolumeClaim {
	pvc := &v1.PersistentVolumeClaim{
		ObjectMeta: metav1.ObjectMeta{Name: pvcName, Namespace: "default", UID: uid},
		Spec: v1.PersistentVolumeClaimSpec{

          varyHeadersBuilder.addLenient(source.readUtf8LineStrict())
        }
        varyHeaders = varyHeadersBuilder.build()

        val statusLine = StatusLine.parse(source.readUtf8LineStrict())
        protocol = statusLine.protocol
        code = statusLine.code
        message = statusLine.message
        val responseHeadersBuilder = Headers.Builder()
        val responseHeaderLineCount = readInt(source)