executable: gradle
args: printValue
flags: "--quiet --stacktrace -I init.gradle -Dorg.gradle.sampletest.env.ENVIRONMENTAL=environmentalValue"

executable: gradle
args: printValue
flags: "--quiet --stacktrace -I init.gradle.kts -Dorg.gradle.sampletest.env.ENVIRONMENTAL=environmentalValue"

                @Model
                void a(A a) { }

                @Mutate
                void addTask(ModelMap<Task> tasks, @Path("$normalisedPath") Item item) {
                    tasks.create("printValue") {
                        it.doLast {
                            println "value: " + item.value
                        }
                    }
                }
            }

			// interface methods that could be used for formatting.
			p.printValue(reflect.ValueOf(f), verb, 0)
		}
	}
}

// printValue is similar to printArg but starts with a reflect value, not an interface{} value.
// It does not handle 'p' and 'T' verbs because these should have been already handled by printArg.
func (p *pp) printValue(value reflect.Value, verb rune, depth int) {

executable: gradle
args: printValue
flags: "--quiet --stacktrace -Dorg.gradle.project.myProjectProp=systemPropertyValue"

                        setNonSerializableSupplier(() -> getName().length());
                    }

                    @TaskAction
                    void printValue() {
                        System.out.println("this.serializableSupplier.get() -> " + this.serializableSupplier.get());

                    private static final AtomicInteger value = new AtomicInteger();

                    private final String projectName = getProject().getName();

                    @TaskAction
                    void printValue() {
                        // When ClassLoaders are reused
                        // the 1st run should print `<project name>.value = 1`
                        // the 2nd run should print `<project name>.value = 2`

                          // (e.g. a named or unnamed enum type)
  kOtherType              // anything else
};

// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
// by the universal printer to print a value of type T when neither
// operator<< nor PrintTo() is defined for T, where kTypeKind is the
// "kind" of T as defined by enum TypeKind.

                          // (e.g. a named or unnamed enum type)
  kOtherType              // anything else
};

// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
// by the universal printer to print a value of type T when neither
// operator<< nor PrintTo() is defined for T, where kTypeKind is the
// "kind" of T as defined by enum TypeKind.

	if v.Kind() != reflect.Interface {
		return v
	}
	if v.IsNil() {
		return reflect.Value{}
	}
	return v.Elem()
}

// printValue writes the textual representation of the value to the output of
// the template.
func (s *state) printValue(n parse.Node, v reflect.Value) {
	s.at(n)
	iface, ok := printableValue(v)
	if !ok {
		s.errorf("can't print %s of type %s", n, v.Type())
	}