*/
    @Override
    @Internal
    public Date getDate() {
        return date != null ? date : defaultDate();
    }

    @Nullable
    private Date defaultDate() {
        final File file = getFile();
        if (file == null) {
            return null;
        }

        final long modified = file.lastModified();

			input:         fmt.Sprintf("%s\r\t\n ", defaultPath),
			expectedOuput: defaultPath,
		},
		{
			name:          "path is suffixed with \"(deleted)\"",
			input:         pathWithSuffix("(deleted)"),
			expectedOuput: defaultPath,
		},
		{
			name:          "path is suffixed with \"(deleted)\" and whitespaces",
			input:         pathWithSuffix(" (deleted)\t"),
			expectedOuput: defaultPath,
		},
	}

			AddedNamespace:               activeNS,
			ExpectCreatedServiceAccounts: sets.NewString(defaultName, managedName).List(),
		},
		"new active namespace missing serviceaccount": {
			ExistingServiceAccounts:      []*v1.ServiceAccount{managedServiceAccount},
			AddedNamespace:               activeNS,
			ExpectCreatedServiceAccounts: []string{defaultName},
		},
		"new active namespace with serviceaccounts": {

        TestFile testFile = optionalFile(propertyName);
        if (testFile != null) {
            return testFile;
        }
        if (defaultPath == null) {
            throw new RuntimeException("You must set the '" + propertyName + "' property to run the integration tests.");
        }
        return testFile(defaultPath);
    }

    @Nullable

        return addRepository(repository, defaultName, Actions.doNothing());
    }

    public <T extends ArtifactRepository> T addRepository(T repository, String defaultName, Action<? super T> configureAction) {
        configureAction.execute(repository);
        return addWithUniqueName(repository, defaultName, addLastAction);
    }

                }

                @Rules
                void rules(CalculateName rules, Thing t) {
                    assert rules.defaultName == null
                    rules.defaultName = 'default'
                    assert rules.defaultName == 'default'
                }
            }

            abstract class CalculateName extends RuleSource {
                @RuleInput

    <option name="VM_PARAMETERS" value="-ea -Djunit.jupiter.extensions.autodetection.enabled=true" />
    <option name="PARAMETERS" value="" />
    <option name="TEST_SEARCH_SCOPE">
      <value defaultName="wholeProject" />
    </option>
    <tag value="!Slow &amp; !Slowish &amp; !Remote &amp; !Android" />
    <method v="2">
      <option name="Make" enabled="true" />
    </method>
  </configuration>

  ): Any {
    val nameAnnotation = parameterContext.findAnnotation(MockWebServerInstance::class.java)
    val name =
      if (nameAnnotation.isPresent) {
        nameAnnotation.get().name
      } else {
        defaultName
      }
    return extensionContext.resource.server(name)
  }

  /** Start the servers passed in as test method parameters. */
  override fun beforeEach(context: ExtensionContext) {

        Boolean::class -> DataTypeInternal.DefaultBooleanDataType.ref
        Long::class -> DataTypeInternal.DefaultLongDataType.ref
        is KClass<*> -> DataTypeRefInternal.DefaultName(DefaultFqName.parse(checkNotNull(qualifiedName)))
        else -> error("unexpected type")
    }


internal
fun checkInScope(
    type: KType,
    typeScope: DataSchemaBuilder.PreIndex
) {

		}
		paths[name] = append(paths[name], path)
	}

	defaultPath := paths[""]
	b.llvmSymbolizer, b.llvmSymbolizerFound = chooseExe([]string{"llvm-symbolizer"}, []string{}, append(paths["llvm-symbolizer"], defaultPath...))
	b.addr2line, b.addr2lineFound = chooseExe([]string{"addr2line"}, []string{"gaddr2line"}, append(paths["addr2line"], defaultPath...))
	// The "-n" option is supported by LLVM since 2011. The output of llvm-nm