hasField(clazz.clazz, 'bar', int).modifiers == Modifier.FINAL
        hasField(extracted, 'bar', int).modifiers == Modifier.FINAL
        hasMethod(clazz.clazz, 'getFoo').modifiers == Modifier.ABSTRACT
        hasMethod(extracted, 'getFoo').modifiers == Modifier.ABSTRACT
        hasMethod(clazz.clazz, 'doBar').modifiers == Modifier.SYNCHRONIZED
        hasMethod(extracted, 'doBar').modifiers == Modifier.SYNCHRONIZED

    }

        }

        then:
        sources.hasDependencyAlias('foo', 'getFoo', "with version <b>1.0</b>")
        sources.hasDependencyAlias('fooBaz', 'getFooBaz', "with version <b>{strictly [1.0, 2.0[; prefer 1.2}</b>")
        sources.hasDependencyAlias('bar', 'getBar', "with version reference <b>barVersion</b>")
        sources.hasDependencyAlias('boo', 'getBoo', "with <b>no version specified</b>")

}

var (
	vetPathOnce sync.Once
	vetExePath  string
	vetPathErr  error
)

func vetCmd(t *testing.T, arg, pkg string) *exec.Cmd {
	cmd := testenv.Command(t, testenv.GoToolPath(t), "vet", "-vettool="+vetPath(t), arg, path.Join("cmd/vet/testdata", pkg))
	cmd.Env = os.Environ()
	return cmd
}

func TestVet(t *testing.T) {
	t.Parallel()
	for _, pkg := range []string{
		"appends",
		"asm",
		"assign",

                attachMultipleForceOnPlatformFailureToEdges(module);
            }
        }
        List<EdgeState> incomingRootEdges = resolveState.getRoot().getIncomingEdges();
        if (!incomingRootEdges.isEmpty()) {
            String rootNodeName = resolveState.getRoot().getMetadata().getName();
            DeprecationLogger.deprecate(
                    String.format(

            existing = mojos.get(indexOf);
        }

        if (existing != null) {
            throw new DuplicateMojoDescriptorException(
                    getGoalPrefix(),
                    mojoDescriptor.getGoal(),
                    existing.getImplementation(),
                    mojoDescriptor.getImplementation());
        } else {
            addComponentDescriptor(mojoDescriptor);
        }
    }

			return nil
		}

		// Not numeric types at this point.

		// Check for bool inference
		bA, okAb := a.bytesToBool()
		bB, okBb := b.bytesToBool()
		if okAb && okBb {
			a.setBool(bA)
			b.setBool(bB)
			return nil
		}

		// Fallback to string
		sA := a.bytesToString()
		sB := b.bytesToString()
		a.setString(sA)
		b.setString(sB)
		return nil

	case okA && !okB:

        then:
        assert newIsolatables.every { it instanceof IsolatedManagedValue }

        and:
        newIsolatables[0].isolate().getFoo() == "bar"
        newIsolatables[1].isolate().getFoo() == "baz"
    }

    def "can serialize/deserialize generated immutable Managed values"() {
        def instantiator = TestUtil.objectInstantiator()

                }

                boolean missing = matcher.group(1) != null;
                String childPath = matcher.group(3);
                tarEntry = unpackTree(treeName, tree.getType(), tree.getRoot(), tarInput, tarEntry, childPath, missing, snapshots, entries);
            }
        }
        if (originMetadata == null) {

                    getId().convention("<no id>");
                }

                @Restricted
                public abstract Property<String> getId();

                public Foo getFoo() {
                    return foo;
                }

                @Configuring
                public void foo(Action<? super Foo> action) {
                    action.execute(foo);
                }

            init();
            logger.warn(
                    "Goal '{}' requires online mode for execution but Maven is currently offline, skipping",
                    event.getMojoExecution().getGoal());
        }
    }

    /**
     * <pre>--- mojo-artifactId:version:goal (mojo-executionId) @ project-artifactId ---</pre>
     */
    @Override
    public void mojoStarted(ExecutionEvent event) {