/**
     *
     *
     *             The path/URL of the POM or {@code null} if
     * unknown.
     *
     *
     */
    private String location;

    // ----------------/
    // - Constructors -/
    // ----------------/

    public InputSource() {}

    public InputSource(org.apache.maven.api.model.InputSource source) {
        this.modelId = source.getModelId();

/**
 * Tests <code>NearestConflictResolver</code>.
 *
 * @see NearestConflictResolver
 */
@Deprecated
class NearestConflictResolverTest extends AbstractConflictResolverTest {
    // constructors -----------------------------------------------------------

    public NearestConflictResolverTest() throws Exception {
        super("nearest");
    }

// Go.
package generics

// Variables with an instantiated type should be shown.
var X Type[int]

// Parameterized types should be shown.
type Type[P any] struct {
	Field P
}

// Constructors for parameterized types should be shown.
func Constructor[lowerCase any]() Type[lowerCase] {
	return Type[lowerCase]{}
}

// MethodA uses a different name for its receiver type parameter.

     */
    boolean addAllInternal(Collection<? extends Task> task);

    /**
     * Creates an instance of the given task type without invoking its constructors. This is used to recreate a task instance from the configuration cache.
     *
     * TODO:configuration-cache - review this
     */
    <T extends Task> T createWithoutConstructor(String name, Class<T> type, long uniqueId);

/**
 * Tests <code>OldestConflictResolver</code>.
 *
 * @see OldestConflictResolver
 */
@Deprecated
class OldestConflictResolverTest extends AbstractConflictResolverTest {
    // constructors -----------------------------------------------------------

    public OldestConflictResolverTest() throws Exception {
        super("oldest");
    }

                .anyMatch(method -> method.isAnnotatedWith(Inject.class));
        }
    };

    private static final DescribedPredicate<JavaClass> injected_by_constructor = new DescribedPredicate<JavaClass>("injected into constructors via @Inject") {
        @Override
        public boolean test(JavaClass javaClass) {
            return javaClass
                .getMethodsWithParameterTypeOfSelf()
                .stream()

limitations under the License.
*/

package request

import (
	"math"
	"testing"
	"time"
)

// TestSeatSecondsString exercises the SeatSeconds constructor and de-constructors (String, ToFloat).
func TestSeatSecondsString(t *testing.T) {
	testCases := []struct {
		ss          SeatSeconds
		expectFloat float64
		expectStr   string
	}{

        }
    }

    private GradleHandle setupStubs(AbstractContinuousIntegrationTest sampleTest) {
        sampleTest.results = [] // fields are null for some reason, perhaps Spock internally modifies constructors
        def gradleHandle = Stub(GradleHandle)
        gradleExecuter.withStdinPipe() >> gradleExecuter
        gradleExecuter.withTasks(_) >> gradleExecuter
        gradleExecuter.withForceInteractive(_) >> gradleExecuter

 public:
  /// Initializer enables constructing an Input object from various kinds of C++
  /// constants such as simple primitive constants and nested initializer lists
  /// representing a multi-dimensional array. Initializer constructors are all
  /// templates, so the aforementioned kinds of C++ constants can be used to
  /// construct an Initializer. Initializer stores the value it got constructed
  /// with in a Tensor object.
  struct Initializer {

    override val name: FqName,
    override val supertypes: Set<FqName>,
    override val properties: List<DataProperty>,
    override val memberFunctions: List<SchemaMemberFunction>,
    override val constructors: List<DataConstructor>
) : DataClass {

    override fun toString(): String = name.simpleName

    companion object Empty : DataClass {
        override val name: FqName = FqName.Empty