@Override
    public boolean isCurrent() {
        return internalOs == CURRENT_OS;
    }

    @Override
    public boolean isWindows() {
        return internalOs.isWindows();
    }

    @Override
    public boolean isLinux() {
        return internalOs.isLinux();
    }

    @Override
    public boolean isMacOsX() {
        return internalOs.isMacOsX();
    }

    @Override

        os.displayName == "operating system 'sunos'"
        os.internalOs == OperatingSystem.SOLARIS
    }

    def "recognises key operating systems"() {
        def os = new DefaultOperatingSystem(name)

        expect:
        os.name == name
        os.internalOs == internalOs

        where:
        name      | internalOs
        "windows" | OperatingSystem.WINDOWS
        "osx"     | OperatingSystem.MAC_OS

import org.gradle.exemplar.test.normalizer.OutputNormalizer
import org.gradle.internal.os.OperatingSystem
import org.gradle.platform.internal.DefaultBuildPlatform

/**
 * This normalizer converts toolchain error message so it doesn't contain platform-specific information.
 */
class PlatformInOutputNormalizer implements OutputNormalizer {
    def static internalOs = OperatingSystem.current()

 */

package org.gradle.nativeplatform.toolchain.internal.msvcpp

import org.gradle.internal.operations.BuildOperationExecutor
import org.gradle.internal.os.OperatingSystem
import org.gradle.internal.work.WorkerLeaseService
import org.gradle.nativeplatform.internal.CompilerOutputFileNamingSchemeFactory
import org.gradle.nativeplatform.platform.internal.OperatingSystemInternal

		}

		// v1beta2 -> apps
		internal2 := &apps.StatefulSetSpec{}
		if err := legacyscheme.Scheme.Convert(tc.stsSepc2, internal2, nil); err != nil {
			t.Errorf("%q - %q: unexpected error: %v", k, "from v1beta2 to extensions", err)
		}
		if !apiequality.Semantic.DeepEqual(internal2, tc.stsSpec1) {
			t.Errorf("%q- %q: expected\n\t%#v, got \n\t%#v", k, "from v1beta2 to extensions", tc.stsSpec1, internal2)
		}
	}
}

		}

		// appsv1 -> apps
		internal2 := &apps.StatefulSetStatus{}
		if err := legacyscheme.Scheme.Convert(tc.stsStatus2, internal2, nil); err != nil {
			t.Errorf("%q - %q: unexpected error: %v", k, "from appsv1 to apps", err)
		}
		if !apiequality.Semantic.DeepEqual(internal2, tc.stsStatus1) {
			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "from appsv1 to apps", tc.stsStatus1, internal2)
		}
	}
}

	return false
}

// Merge combines the intervals from "is" and "is2" and returns
// a new Intervals object containing all combined ranges from the
// two inputs.
func (is Intervals) Merge(is2 Intervals) Intervals {
	if len(is) == 0 {
		return is2
	} else if len(is2) == 0 {
		return is
	}
	// walk the combined set of intervals and merge them together.
	var ret Intervals
	var pv pairVisitor
	cur := pv.init(is, is2)

 * <p>
 * For example, the implementation of such an API might add validations checking third-party
 * plugins or build scripts for compliance with some limitations imposed by Gradle. In the internal
 * code, one does not expect such limitations.
 * <p>
 * This annotations should only be applied to Gradle public API declarations.
 *
 * @see AllowUsingApiForExternalUse
 */
@Retention(RetentionPolicy.CLASS)

import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.connection.RealConnection

internal fun parseCookie(
  currentTimeMillis: Long,
  url: HttpUrl,
  setCookie: String,
): Cookie? = Cookie.parse(currentTimeMillis, url, setCookie)

internal fun cookieToString(
  cookie: Cookie,
  forObsoleteRfc2965: Boolean,

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package internal contains non-exported functionality that are used by
// packages in the text repository.
package internal // import "golang.org/x/text/internal"

import (
	"sort"

	"golang.org/x/text/language"
)

// SortTags sorts tags in place.
func SortTags(tags []language.Tag) {