err := v.DecodeMsg(dc)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkDecodeDiskInfoMsgp(b *testing.B) {
	v := DiskInfo{
		Total:     1000,
		Free:      1000,
		Used:      1000,
		FSType:    "xfs",
		RootDisk:  true,
		Healing:   true,
		Endpoint:  "http://localhost:9001/tmp/drive1",
		MountPath: "/tmp/drive1",
		ID:        "uuid",
		Error:     "",
	}
	var buf bytes.Buffer

    @Test
    fun `handles the hidden properties correctly`() {
        val aType = schema.dataClassesByFqName.getValue(DefaultFqName.parse(HasHiddenProperty::class.qualifiedName!!))
        assertTrue { aType.properties.single { it.name == "y" }.isHiddenInDsl }

        val result = schema.resolve(
            """
            x = 1
            y = 2

        return getTree().first(type, predicate)
    }

    @Override
    @SuppressWarnings("GrUnnecessaryPublicModifier")
    public <T extends BuildOperationType<?, ?>> boolean isType(BuildOperationRecord record, Class<T> type) {
        return getTree().isType(record, type)
    }

    @Override
    @SuppressWarnings("GrUnnecessaryPublicModifier")

                        "Illegal call of ${expression.name} at ${expression.positionString}"
                    }

                    val a = valueArguments[0]
                    val aType = a.getArgumentExpression()?.getKaType()
                    if (aType == null) {
                        errors.add("'${a.text}' has no type at ${a.positionString}")
                        super.visitCallExpression(expression)
                        return

//go:generate stringer -type=SymKind
const (
	Sxxx SymKind = iota
	STEXT
	SELFRXSECT
	SMACHOPLT

	// Read-only sections.
	STYPE
	SSTRING
	SGOSTRING
	SGOFUNC
	SGCBITS
	SRODATA
	SFUNCTAB

	SELFROSECT

	// Read-only sections with relocations.
	//
	// Types STYPE-SFUNCTAB above are written to the .rodata section by default.
	// When linking a shared object, some conceptually "read only" types need to

func (*VolumeProvider) GetQuotaApplier(mountpoint string, backingDev string) LinuxVolumeQuotaApplier {
	for _, fsType := range linuxSupportedFilesystems {
		if isFilesystemOfType(mountpoint, backingDev, fsType.typeMagic) {
			return linuxVolumeQuotaApplier{mountpoint: mountpoint,
				maxQuota:         fsType.maxQuota,
				allowEmptyOutput: fsType.allowEmptyOutput,
			}
		}
	}
	return nil
}

type linuxVolumeQuotaApplier struct {

        assert this.classifier == classifier
    }

    IvyDescriptorArtifact hasConf(def conf) {
        assert this.conf == conf
        return this
    }

    IvyDescriptorArtifact hasType(def type) {
        assert this.type == type
        return this
    }

    String getClassifier() {
        this.mavenAttributes.get("classifier")
    }

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package mountinfo

// mountInfo - This represents a single line in /proc/mounts.
type mountInfo struct {
	Device  string
	Path    string
	FSType  string
	Options []string
	Freq    string
	Pass    string
}

func (m mountInfo) String() string {
	return m.Path
}

// mountInfos - This represents the entire /proc/mounts.

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import jsinterop.annotations.JsMethod;
import jsinterop.annotations.JsPackage;
import jsinterop.annotations.JsProperty;
import jsinterop.annotations.JsType;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Minimal GWT emulation of {@code com.google.common.collect.Platform}.
 *
 * @author Hayward Chan
 */
final class Platform {

    String groupId
    String artifactId
    String version
    String classifier
    String type
    boolean optional
    Collection<MavenDependencyExclusion> exclusions = []

    MavenDependency hasType(def type) {
        assert this.type == type
        return this
    }

    @Override
    public String toString() {