public static void reset(ChocolateyConfiguration config)
{
string packagesInstallPath = get_package_install_path();
string badPackagesPath = get_package_install_path() + "-bad";
string backupPackagesPath = get_package_install_path() + "-bkp";
string shimsPath = ApplicationParameters.ShimsLocation;
_fileSystem.delete_directory_if_exists(config.CacheLocation, recursive: true, overrideAttributes: true);
_fileSystem.delete_directory_if_exists(config.Sources, recursive: true, overrideAttributes: true);
_fileSystem.delete_directory_if_exists(packagesInstallPath, recursive: true, overrideAttributes: true);
_fileSystem.delete_directory_if_exists(shimsPath, recursive: true, overrideAttributes: true);
_fileSystem.delete_directory_if_exists(badPackagesPath, recursive: true, overrideAttributes: true);
_fileSystem.delete_directory_if_exists(backupPackagesPath, recursive: true, overrideAttributes: true);
_fileSystem.delete_directory_if_exists(_fileSystem.combine_paths(get_top_level(), ".chocolatey"), recursive: true, overrideAttributes: true);
_fileSystem.delete_directory_if_exists(_fileSystem.combine_paths(get_top_level(), "extensions"), recursive: true, overrideAttributes: true);
_fileSystem.create_directory(config.CacheLocation);
_fileSystem.create_directory(config.Sources);
_fileSystem.create_directory(packagesInstallPath);
_fileSystem.create_directory(shimsPath);
_fileSystem.create_directory(badPackagesPath);
_fileSystem.create_directory(backupPackagesPath);
_fileSystem.create_directory(_fileSystem.combine_paths(get_top_level(), ".chocolatey"));
_fileSystem.create_directory(_fileSystem.combine_paths(get_top_level(), "extensions"));
PowershellExecutor.AllowUseWindow = false;
}
public override void Context()
{
Configuration = Scenario.pack();
Scenario.reset(Configuration);
Scenario.add_files(new[] { new Tuple<string, string>("myPackage.nuspec", NuspecContent) });
Service = NUnitSetup.Container.GetInstance<INugetService>();
}
public override void BeforeEachSpec()
{
args = new List<string>();
config = new ChocolateyConfiguration();
setOptions = set => { };
afterParse = list => { };
validateConfiguration = () => { };
helpMessage = () => { };
helpMessageContents.Clear();
}
public static void add_packages_to_source_location(ChocolateyConfiguration config, string pattern)
{
_fileSystem.create_directory_if_not_exists(config.Sources);
var contextDir = _fileSystem.combine_paths(get_top_level(), "context");
var files = _fileSystem.get_files(contextDir, pattern, SearchOption.AllDirectories);
foreach (var file in files.or_empty_list_if_null())
{
_fileSystem.copy_file(_fileSystem.get_full_path(file), _fileSystem.combine_paths(config.Sources, _fileSystem.get_file_name(file)), overwriteExisting: true);
}
}
public override void Context()
{
Configuration = Scenario.list();
Scenario.reset(Configuration);
Scenario.add_packages_to_source_location(Configuration, Configuration.Input + "*" + Constants.PackageExtension);
Scenario.add_packages_to_source_location(Configuration, "installpackage*" + Constants.PackageExtension);
Scenario.install_package(Configuration, "installpackage", "1.0.0");
Scenario.install_package(Configuration, "upgradepackage", "1.0.0");
Service = NUnitSetup.Container.GetInstance<IChocolateyPackageService>();
}
public static void reset_environment_variables(ChocolateyConfiguration config)
{
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyPackageInstallLocation, null);
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyPackageInstallerType, null);
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyPackageExitCode, null);
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyIgnoreChecksums, null);
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyAllowEmptyChecksums, null);
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyAllowEmptyChecksumsSecure, null);
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyPowerShellHost, null);
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyForce, null);
}
public override void Context()
{
Configuration = Scenario.install();
Scenario.reset(Configuration);
Configuration.PackageNames = Configuration.Input = "installpackage";
Scenario.add_packages_to_source_location(Configuration, Configuration.Input + "*" + Constants.PackageExtension);
Scenario.add_packages_to_source_location(Configuration, "badpackage.1*" + Constants.PackageExtension);
Service = NUnitSetup.Container.GetInstance<IChocolateyPackageService>();
CommandExecutor = new CommandExecutor(NUnitSetup.Container.GetInstance<IFileSystem>());
}
public static void install_package(ChocolateyConfiguration config, string packageId, string version)
{
if (_service == null)
{
_service = NUnitSetup.Container.GetInstance<IChocolateyPackageService>();
}
var installConfig = config.deep_copy();
installConfig.PackageNames = packageId;
installConfig.Version = version;
_service.install_run(installConfig);
NUnitSetup.MockLogger.Messages.Clear();
}
public static void set_environment_variables(ChocolateyConfiguration config)
{
reset_environment_variables(config);
Environment.SetEnvironmentVariable(ApplicationParameters.ChocolateyInstallEnvironmentVariableName, ApplicationParameters.InstallLocation);
Environment.SetEnvironmentVariable("CHOCOLATEY_VERSION", config.Information.ChocolateyVersion);
Environment.SetEnvironmentVariable("CHOCOLATEY_VERSION_PRODUCT", config.Information.ChocolateyProductVersion);
Environment.SetEnvironmentVariable("OS_PLATFORM", config.Information.PlatformType.get_description_or_value());
Environment.SetEnvironmentVariable("OS_VERSION", config.Information.PlatformVersion.to_string());
Environment.SetEnvironmentVariable("OS_NAME", config.Information.PlatformName.to_string());
// experimental until we know if this value returns correctly based on the OS and not the current process.
Environment.SetEnvironmentVariable("OS_IS64BIT", config.Information.Is64Bit ? "true" : "false");
Environment.SetEnvironmentVariable("IS_ADMIN", config.Information.IsUserAdministrator ? "true" : "false");
Environment.SetEnvironmentVariable("IS_PROCESSELEVATED", config.Information.IsProcessElevated ? "true" : "false");
Environment.SetEnvironmentVariable("TEMP", config.CacheLocation);
Environment.SetEnvironmentVariable("TMP", config.CacheLocation);
if (config.Debug) Environment.SetEnvironmentVariable("ChocolateyEnvironmentDebug", "true");
if (config.Verbose) Environment.SetEnvironmentVariable("ChocolateyEnvironmentVerbose", "true");
if (!config.Features.ChecksumFiles) Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyIgnoreChecksums, "true");
if (config.Features.AllowEmptyChecksums) Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyAllowEmptyChecksums, "true");
if (config.Features.AllowEmptyChecksumsSecure) Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyAllowEmptyChecksumsSecure, "true");
if (config.Features.ScriptsCheckLastExitCode) Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyCheckLastExitCode, "true");
Environment.SetEnvironmentVariable("chocolateyRequestTimeout", config.WebRequestTimeoutSeconds.to_string() + "000");
Environment.SetEnvironmentVariable("chocolateyResponseTimeout", config.CommandExecutionTimeoutSeconds.to_string() + "000");
if (!string.IsNullOrWhiteSpace(config.Proxy.Location))
{
var proxyCreds = string.Empty;
if (!string.IsNullOrWhiteSpace(config.Proxy.User) &&
!string.IsNullOrWhiteSpace(config.Proxy.EncryptedPassword)
)
{
proxyCreds = "{0}:{1}@".format_with(config.Proxy.User, NugetEncryptionUtility.DecryptString(config.Proxy.EncryptedPassword));
Environment.SetEnvironmentVariable("chocolateyProxyUser", config.Proxy.User);
Environment.SetEnvironmentVariable("chocolateyProxyPassword", NugetEncryptionUtility.DecryptString(config.Proxy.EncryptedPassword));
}
Environment.SetEnvironmentVariable("http_proxy", "{0}{1}".format_with(proxyCreds, config.Proxy.Location));
Environment.SetEnvironmentVariable("https_proxy", "{0}{1}".format_with(proxyCreds, config.Proxy.Location));
Environment.SetEnvironmentVariable("chocolateyProxyLocation", config.Proxy.Location);
}
if (config.Features.UsePowerShellHost) Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyPowerShellHost, "true");
if (config.Force) Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyForce, "true");
set_licensed_environment(config);
}
public override void Context()
{
Configuration = Scenario.upgrade();
Scenario.reset(Configuration);
Configuration.PackageNames = Configuration.Input = "upgradepackage";
Scenario.add_packages_to_source_location(Configuration, Configuration.Input + "*" + Constants.PackageExtension);
Scenario.add_packages_to_source_location(Configuration, "installpackage*" + Constants.PackageExtension);
Scenario.add_packages_to_source_location(Configuration, "badpackage*" + Constants.PackageExtension);
Scenario.install_package(Configuration, "installpackage", "1.0.0");
Scenario.install_package(Configuration, "upgradepackage", "1.0.0");
Configuration.SkipPackageInstallProvider = true;
Scenario.install_package(Configuration, "badpackage", "1.0");
Configuration.SkipPackageInstallProvider = false;
Service = NUnitSetup.Container.GetInstance<IChocolateyPackageService>();
}
public override void Context()
{
Configuration = Scenario.pin();
Scenario.reset(Configuration);
Scenario.add_packages_to_source_location(Configuration, Configuration.Input + "*" + Constants.PackageExtension);
Scenario.add_packages_to_source_location(Configuration, "installpackage*" + Constants.PackageExtension);
Scenario.install_package(Configuration, "installpackage", "1.0.0");
Scenario.install_package(Configuration, "upgradepackage", "1.0.0");
Scenario.install_package(Configuration, "hasdependency", "1.0.0");
var commands = NUnitSetup.Container.GetAllInstances<ICommand>();
Service = commands.Where(
(c) =>
{
var attributes = c.GetType().GetCustomAttributes(typeof(CommandForAttribute), false);
return attributes.Cast<CommandForAttribute>().Any(attribute => attribute.CommandName.is_equal_to(Configuration.CommandName));
}).FirstOrDefault() as ChocolateyPinCommand;
Configuration.Sources = ApplicationParameters.PackagesLocation;
Configuration.ListCommand.LocalOnly = true;
Configuration.AllVersions = true;
Configuration.Prerelease = true;
}
public static void install_package(ChocolateyConfiguration config, string packageId, string version)
{
if (_service == null)
{
_service= NUnitSetup.Container.GetInstance<IChocolateyPackageService>();
}
var originalPackageName = config.PackageNames;
var originalPackageVersion = config.Version;
config.PackageNames = packageId;
config.Version = version;
_service.install_run(config);
config.PackageNames = originalPackageName;
config.Version = originalPackageVersion;
//var pattern = "{0}.{1}{2}".format_with(packageId, string.IsNullOrWhiteSpace(version) ? "*" : version, Constants.PackageExtension);
//var files = _fileSystem.get_files(config.Sources, pattern);
//foreach (var file in files)
//{
// var packageManager = NugetCommon.GetPackageManager(config, new ChocolateyNugetLogger(), null, null, false);
// packageManager.InstallPackage(new OptimizedZipPackage(file), false,false);
//}
}
public static void reset_environment_variables(ChocolateyConfiguration config)
{
Environment.SetEnvironmentVariable(ApplicationParameters.ChocolateyPackageInstallLocationEnvironmentVariableName, null);
Environment.SetEnvironmentVariable(ApplicationParameters.ChocolateyPackageInstallerTypeEnvironmentVariableName, null);
}
private void build_packages(Container container, ChocolateyConfiguration config)
{
var fileSystem = container.GetInstance<IFileSystem>();
var contextDir = fileSystem.combine_paths(fileSystem.get_directory_name(fileSystem.get_current_assembly_path()), "context");
// short-circuit building packages if they are already there.
if (fileSystem.get_files(contextDir, "*.nupkg").Any())
{
Console.WriteLine("Packages have already been built. Skipping... - If you need to rebuild packages, delete all nupkg files in {0}.".format_with(contextDir));
return;
}
var files = fileSystem.get_files(contextDir, "*.nuspec", SearchOption.AllDirectories);
var command = container.GetInstance<ChocolateyPackCommand>();
foreach (var file in files.or_empty_list_if_null())
{
config.Input = file;
Console.WriteLine("Building {0}".format_with(file));
command.run(config);
}
Console.WriteLine("Moving all nupkgs in {0} to context directory.".format_with(fileSystem.get_current_directory()));
var nupkgs = fileSystem.get_files(fileSystem.get_current_directory(), "*.nupkg");
foreach (var nupkg in nupkgs.or_empty_list_if_null())
{
fileSystem.copy_file(nupkg, fileSystem.combine_paths(contextDir, fileSystem.get_file_name(nupkg)), overwriteExisting: true);
fileSystem.delete_file(nupkg);
}
//concurrency issues when packages are first built out during testing
Thread.Sleep(2000);
Console.WriteLine("Continuing with tests now after waiting for files to finish moving.");
}
private void unpack_self(Container container, ChocolateyConfiguration config)
{
var unpackCommand = container.GetInstance<ChocolateyUnpackSelfCommand>();
unpackCommand.run(config);
}
public static void reset_environment_variables(ChocolateyConfiguration config)
{
Environment.SetEnvironmentVariable(ApplicationParameters.ChocolateyPackageInstallLocationEnvironmentVariableName, null);
Environment.SetEnvironmentVariable(ApplicationParameters.ChocolateyPackageInstallerTypeEnvironmentVariableName, null);
}
private static void set_licensed_environment(ChocolateyConfiguration config)
{
if (!config.Information.IsLicensedVersion) return;
var licenseAssembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetName().Name.is_equal_to("chocolatey.licensed"));
if (licenseAssembly != null)
{
Type licensedEnvironmentSettings = licenseAssembly.GetType(ApplicationParameters.LicensedEnvironmentSettings, throwOnError: false, ignoreCase: true);
if (licensedEnvironmentSettings == null)
{
if (config.RegularOutput) "chocolatey".Log().Warn(
ChocolateyLoggers.Important, @"Unable to set licensed environment settings. Please upgrade to a newer
licensed version.");
return;
}
try
{
object componentClass = Activator.CreateInstance(licensedEnvironmentSettings);
licensedEnvironmentSettings.InvokeMember(
SET_ENVIRONMENT_METHOD,
BindingFlags.InvokeMethod,
null,
componentClass,
new Object[] { config }
);
}
catch (Exception ex)
{
"chocolatey".Log().Error(
ChocolateyLoggers.Important,
@"Error when setting environment for '{0}':{1} {2}".format_with(
licensedEnvironmentSettings.FullName,
Environment.NewLine,
ex.Message
));
}
}
}
private static void set_licensed_environment(ChocolateyConfiguration config)
{
if (!config.Information.IsLicensedVersion)
{
return;
}
Environment.SetEnvironmentVariable("ChocolateyLicenseType", config.Information.LicenseType);
var licenseAssembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetName().Name.is_equal_to("chocolatey.licensed"));
if (licenseAssembly != null)
{
Type licensedEnvironmentSettings = licenseAssembly.GetType(ApplicationParameters.LicensedEnvironmentSettings, throwOnError: false, ignoreCase: true);
if (licensedEnvironmentSettings == null)
{
if (config.RegularOutput)
{
"chocolatey".Log().Warn(
ChocolateyLoggers.Important, @"Unable to set licensed environment settings. Please upgrade to a newer
licensed version (choco upgrade chocolatey.extension).");
}
return;
}
try
{
object componentClass = Activator.CreateInstance(licensedEnvironmentSettings);
licensedEnvironmentSettings.InvokeMember(
SET_ENVIRONMENT_METHOD,
BindingFlags.InvokeMethod,
null,
componentClass,
new Object[] { config }
);
}
catch (Exception ex)
{
var isDebug = ApplicationParameters.is_debug_mode_cli_primitive();
if (config.Debug)
{
isDebug = true;
}
var message = isDebug ? ex.ToString() : ex.Message;
if (isDebug && ex.InnerException != null)
{
message += "{0}{1}".format_with(Environment.NewLine, ex.InnerException.ToString());
}
"chocolatey".Log().Error(
ChocolateyLoggers.Important,
@"Error when setting environment for '{0}':{1} {2}".format_with(
licensedEnvironmentSettings.FullName,
Environment.NewLine,
message
));
}
}
}
public static void set_environment_variables(ChocolateyConfiguration config)
{
reset_environment_variables(config);
Environment.SetEnvironmentVariable(ApplicationParameters.ChocolateyInstallEnvironmentVariableName, ApplicationParameters.InstallLocation);
Environment.SetEnvironmentVariable("CHOCOLATEY_VERSION", config.Information.ChocolateyVersion);
Environment.SetEnvironmentVariable("CHOCOLATEY_VERSION_PRODUCT", config.Information.ChocolateyProductVersion);
Environment.SetEnvironmentVariable("OS_PLATFORM", config.Information.PlatformType.get_description_or_value());
Environment.SetEnvironmentVariable("OS_VERSION", config.Information.PlatformVersion.to_string());
Environment.SetEnvironmentVariable("OS_NAME", config.Information.PlatformName.to_string());
// experimental until we know if this value returns correctly based on the OS and not the current process.
Environment.SetEnvironmentVariable("OS_IS64BIT", config.Information.Is64Bit ? "true" : "false");
Environment.SetEnvironmentVariable("IS_ADMIN", config.Information.IsUserAdministrator ? "true" : "false");
Environment.SetEnvironmentVariable("IS_PROCESSELEVATED", config.Information.IsProcessElevated ? "true" : "false");
Environment.SetEnvironmentVariable("TEMP", config.CacheLocation);
Environment.SetEnvironmentVariable("TMP", config.CacheLocation);
if (config.Debug)
{
Environment.SetEnvironmentVariable("ChocolateyEnvironmentDebug", "true");
}
if (config.Verbose)
{
Environment.SetEnvironmentVariable("ChocolateyEnvironmentVerbose", "true");
}
if (!config.Features.ChecksumFiles)
{
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyIgnoreChecksums, "true");
}
if (config.Features.AllowEmptyChecksums)
{
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyAllowEmptyChecksums, "true");
}
if (config.Features.AllowEmptyChecksumsSecure)
{
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyAllowEmptyChecksumsSecure, "true");
}
Environment.SetEnvironmentVariable("chocolateyRequestTimeout", config.WebRequestTimeoutSeconds.to_string() + "000");
Environment.SetEnvironmentVariable("chocolateyResponseTimeout", config.CommandExecutionTimeoutSeconds.to_string() + "000");
if (!string.IsNullOrWhiteSpace(config.Proxy.Location))
{
var proxyCreds = string.Empty;
if (!string.IsNullOrWhiteSpace(config.Proxy.User) &&
!string.IsNullOrWhiteSpace(config.Proxy.EncryptedPassword)
)
{
proxyCreds = "{0}:{1}@".format_with(config.Proxy.User, NugetEncryptionUtility.DecryptString(config.Proxy.EncryptedPassword));
Environment.SetEnvironmentVariable("chocolateyProxyUser", config.Proxy.User);
Environment.SetEnvironmentVariable("chocolateyProxyPassword", NugetEncryptionUtility.DecryptString(config.Proxy.EncryptedPassword));
}
Environment.SetEnvironmentVariable("http_proxy", "{0}{1}".format_with(proxyCreds, config.Proxy.Location));
Environment.SetEnvironmentVariable("https_proxy", "{0}{1}".format_with(proxyCreds, config.Proxy.Location));
Environment.SetEnvironmentVariable("chocolateyProxyLocation", config.Proxy.Location);
}
if (config.Features.UsePowerShellHost)
{
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyPowerShellHost, "true");
}
if (config.Force)
{
Environment.SetEnvironmentVariable(ApplicationParameters.Environment.ChocolateyForce, "true");
}
set_licensed_environment(config);
}
public void when_testing_a_class_against_is_not_null_should_pass()
{
var test = new ChocolateyConfiguration();
Ensure.that(() => test).is_not_null();
}
/// <summary>
/// Parses arguments and updates the configuration
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="configuration">The configuration</param>
/// <param name="setOptions">The set options.</param>
/// <param name="afterParse">Actions to take after parsing</param>
/// <param name="validateConfiguration">Validate the configuration</param>
/// <param name="helpMessage">The help message.</param>
public static void parse_arguments_and_update_configuration(ICollection<string> args,
ChocolateyConfiguration configuration,
Action<OptionSet> setOptions,
Action<IList<string>> afterParse,
Action validateConfiguration,
Action helpMessage)
{
IList<string> unparsedArguments = new List<string>();
// add help only once
if (_optionSet.Count == 0)
{
_optionSet
.Add("?|help|h",
"Prints out the help menu.",
option => configuration.HelpRequested = option != null);
}
if (setOptions != null)
{
setOptions(_optionSet);
}
try
{
unparsedArguments = _optionSet.Parse(args);
}
catch (OptionException)
{
show_help(_optionSet, helpMessage);
}
// the command argument
if (string.IsNullOrWhiteSpace(configuration.CommandName) && unparsedArguments.Contains(args.FirstOrDefault()))
{
var commandName = args.FirstOrDefault();
if (!Regex.IsMatch(commandName, @"^[-\/+]"))
{
configuration.CommandName = commandName;
}
else if (commandName.is_equal_to("-v") || commandName.is_equal_to("--version"))
{
// skip help menu
}
else
{
configuration.HelpRequested = true;
}
}
if (afterParse != null)
{
afterParse(unparsedArguments);
}
if (configuration.HelpRequested)
{
show_help(_optionSet, helpMessage);
}
else
{
if (validateConfiguration != null)
{
validateConfiguration();
}
}
}
/// <summary>
/// Parses arguments and updates the configuration
/// </summary>
/// <param name="args">The arguments.</param>
/// <param name="configuration">The configuration</param>
/// <param name="setOptions">The set options.</param>
/// <param name="afterParse">Actions to take after parsing</param>
/// <param name="validateConfiguration">Validate the configuration</param>
/// <param name="helpMessage">The help message.</param>
public static void parse_arguments_and_update_configuration(ICollection <string> args,
ChocolateyConfiguration configuration,
Action <OptionSet> setOptions,
Action <IList <string> > afterParse,
Action validateConfiguration,
Action helpMessage)
{
IList <string> unparsedArguments = new List <string>();
// add help only once
if (_optionSet.Count == 0)
{
_optionSet
.Add("?|help|h",
"Prints out the help menu.",
option => configuration.HelpRequested = option != null);
}
if (setOptions != null)
{
setOptions(_optionSet);
}
try
{
unparsedArguments = _optionSet.Parse(args);
}
catch (OptionException)
{
show_help(_optionSet, helpMessage);
configuration.UnsuccessfulParsing = true;
}
// the command argument
if (string.IsNullOrWhiteSpace(configuration.CommandName) && unparsedArguments.Contains(args.FirstOrDefault()))
{
var commandName = args.FirstOrDefault();
if (!Regex.IsMatch(commandName, @"^[-\/+]"))
{
configuration.CommandName = commandName;
}
else if (commandName.is_equal_to("-v") || commandName.is_equal_to("--version"))
{
// skip help menu
}
else
{
configuration.HelpRequested = true;
configuration.UnsuccessfulParsing = true;
}
}
if (afterParse != null)
{
afterParse(unparsedArguments);
}
if (configuration.HelpRequested)
{
show_help(_optionSet, helpMessage);
}
else
{
if (validateConfiguration != null)
{
validateConfiguration();
}
}
}