Type1Message type1 = new Type1Message(src);
                Type2Message type2 = new Type2Message(tc, type1, challenge, null);
                msg = new String(Base64.encode(type2.toByteArray()), "US-ASCII");
                resp.setHeader("WWW-Authenticate", "NTLM " + msg);
            }
            else if ( src[ 8 ] == 3 ) {
                Type3Message type3 = new Type3Message(src);

        provider.hasTypeForExtension(type2.extension)
        !provider.hasTypeForExtension(type3.extension)
    }

    def "default type"() {
        expect:
        provider.defaultType == type1

        when:
        provider.defaultType = type2.extension

        then:
        provider.defaultType == type2
    }

    def "can't set default type to unregistered type"() {
        when:

                Type1Message type1 = new Type1Message(src);
                Type2Message type2 = new Type2Message(type1, challenge, null);
                msg = Base64.encode(type2.toByteArray());
                resp.setHeader( "WWW-Authenticate", "NTLM " + msg );
            } else if (src[8] == 3) {
                Type3Message type3 = new Type3Message(src);
                byte[] lmResponse = type3.getLMResponse();

// and success cases.
func TestCrossDeviceMountPaths(t *testing.T) {
	successCase := `/dev/0 /path/to/0/1 type0 flags 0 0
		/dev/1    /path/to/1   type1	flags 1 1
		/dev/2 /path/to/1/2 type2 flags,1,2=3 2 2
                /dev/3 /path/to/1.1 type3 flags,1,2=3 3 3
		`
	var err error
	dir := t.TempDir()
	mountsPath := filepath.Join(dir, "mounts")

	ctx1, t1 := trace.NewTask(ctx0, "type1")

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}
	t1.End()

	// Create a task that starts during the trace and ends after.
	ctx2, t2 := trace.NewTask(ctx0, "type2")

	// Create a task that starts and ends during the trace.
	ctx3, t3 := trace.NewTask(baseCtx, "type3")

	// Generate some events.

    override fun KaSession.checkTypes(expectedResult: Boolean, type1: KaType, type2: KaType, testServices: TestServices) {
        testServices.assertions.assertEquals(
            expectedResult,
            type1.isSubTypeOf(type2, KaSubtypingErrorTypePolicy.LENIENT),
        ) {
            "Expected `$type1` to ${if (!expectedResult) "not " else ""}be a subtype of `$type2` with error type leniency" +
                    " (`$resultDirective`)."

        expect:
        type.signature == 'org.gradle.SomeType<Type1, Type2>'
    }

    def formatsSignatureForWildcardType() {
        type.setWildcard()

        expect:
        type.signature == '?'
    }

    def formatsSignatureForWildcardWithUpperBound() {
        type.setUpperBounds(new TypeMetaData('OtherType'))

        expect:

const Const1 = 0
var   Var1   = 0

type (
	Type1     int
	Type1_Foo int
	Type1_foo int
	type2     int

	Embed struct { Type1 }
	Uembed struct { type2 }
)

func Func1()     {}
func Func1_Foo() {}
func Func1_foo() {}
func func2()     {}

func (Type1) Func1() {}
func (Type1) Func1_Foo() {}
func (Type1) Func1_foo() {}
func (Type1) func2() {}

func (type2) Func1() {}

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

package org.gradle.internal.snapshot.impl

enum Type1 {
    ONE {}, TWO {}

    def store = new DefaultModelSchemaStore(extractor)

    def "caches schema for a type"() {
        // intentionally use two different “instances” of the same type
        def type1 = ModelType.of(SimpleManagedType)
        def type2 = ModelType.of(SimpleManagedType)

        expect:
        store.getSchema(type1).is(store.getSchema(type2))
    }

    def "each thread receives same schema object"() {