}

func direntReclen(buf []byte) (uint64, bool) {
	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
}

func direntNamlen(buf []byte) (uint64, bool) {
	reclen, ok := direntReclen(buf)
	if !ok {
		return 0, false
	}
	return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
}

//sys	getdirent(fd int, buf []byte) (n int, err error)

}

func direntReclen(buf []byte) (uint64, bool) {
	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
}

func direntNamlen(buf []byte) (uint64, bool) {
	reclen, ok := direntReclen(buf)
	if !ok {
		return 0, false
	}
	return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
}

func Pipe(p []int) (err error) {
	return Pipe2(p, 0)
}

        succeeds('customTask')

        then:
        def result = operations.first(SnapshotTaskInputsBuildOperationType).result

        then:
        result.hash != null
        result.inputValueHashes.keySet() == ['input1', 'input2'] as Set
        result.outputPropertyNames == ['outputFile1', 'outputFile2']
    }

    def "task output caching key is exposed when scan plugin is applied"() {
        given:

        def projectConfigurations = contexts*.asVariantName as Set
        projectFile.projectConfigurations.keySet() == projectConfigurations

        and:
        solutionFile.assertReferencesProject(projectFile, projectConfigurations)
    }

    @ToBeFixedForConfigurationCache

## Erforderliche Parameter

Wenn wir keine Validierungen oder Metadaten haben, können wir den `q` Query-Parameter erforderlich machen, indem wir einfach keinen Defaultwert deklarieren, wie in:

```Python
q: str
```

statt:

```Python
q: Union[str, None] = None
```

Aber jetzt deklarieren wir den Parameter mit `Query`, wie in:

  public void testViewSerialization() {
    Map<String, Integer> map = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3);
    SerializableTester.reserializeAndAssert(map.entrySet());
    SerializableTester.reserializeAndAssert(map.keySet());
    assertEquals(
        Lists.newArrayList(map.values()),
        Lists.newArrayList(SerializableTester.reserialize(map.values())));
  }

  @GwtIncompatible // SerializableTester

            }
            return result;
          }
        });
  }

  @Override
  ImmutableSet<K> createKeySet() {
    return ImmutableSet.unsafeDelegate(delegate.keySet());
  }

  @Override
  ImmutableCollection<V> createValues() {
    return ImmutableCollection.unsafeDelegate(delegate.values());
  }

  @Override
  public int size() {
    return delegate.size();

        }
        return t;
    }

    private List<String> findPossibleMatches(String fullyQualifiedClassName) {
        List<String> candidates = new ArrayList<String>();
        for (String className : classes.keySet()) {
            if (getLevenshteinDistance(fullyQualifiedClassName, className) < 8) {
                candidates.add(className);
            }
        }
        return candidates;
    }

    @Override

            return isIncubatingAttributeValue(key.getType(), value);
        }
    }

    @SuppressWarnings("unchecked")
    public static boolean isAnyIncubating(AttributeContainer attributes) {
        return attributes.keySet().stream().map(k -> Pair.of((Attribute<Object>) k, (Object) attributes.getAttribute(k))).anyMatch(IncubatingAttributesChecker::isIncubating);
    }

    private static <T> boolean isIncubating(Pair<Attribute<T>, T> attributePair) {

</ivy-module>
"""
        parse(parseContext, file)

        then:
        metadata.id == componentId("myorg", "mymodule", "myrev")
        metadata.status == "integration"
        metadata.configurationDefinitions.keySet() == ["default"] as Set
        metadata.dependencies.empty
        !hasGradleMetadataRedirectionMarker

        artifact()
    }

    def "adds implicit configurations"() {
        when: