protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var apiHeaders = new[] { API_TIMESTAMP_HEADER, API_SIGNATURE_HEADER, API_KEY_HEADER };
IEnumerable<string> headerKeys = request.Headers
.Where(h => h.Value.Any() && !string.IsNullOrEmpty(h.Value.First()))
.Select(h => h.Key);
if (!apiHeaders.Except(headerKeys).Any())
{
string apiTimestamp = request.Headers.First(h => h.Key == API_TIMESTAMP_HEADER).Value.FirstOrDefault();
DateTime timestampValue = long.Parse(apiTimestamp).UnixTimeToDateTime();
DateTime serverTime = DateTime.UtcNow;
if (serverTime.Subtract(TimeSpan.FromSeconds(API_TIMESTAMP_WITHIN_SECONDS)) <= timestampValue && timestampValue <= serverTime)
{
string generatedSignature = GenerateSignature(request);
string retrievedSignature = request.Headers.First(h => h.Key == API_SIGNATURE_HEADER).Value.FirstOrDefault();
if (!string.IsNullOrEmpty(generatedSignature) && generatedSignature.Equals(retrievedSignature))
{
return base.SendAsync(request, cancellationToken);
}
}
}
var response = request.CreateErrorResponse(HttpStatusCode.Unauthorized, new HttpError("API Key Credentials Invalid"));
return Task.FromResult(response);
}
public CacheSet<string> SelectByIDs(string EntityName, System.Collections.Generic.IEnumerable<string> EntityIDs)
{
CacheSet<string> Result = new CacheSet<string>();
if (!EntityNames.Contains(EntityName))
{
Result.WantIDs = EntityIDs.ToList<string>();
return Result;
}
List<string> IDs = new List<string>();
List<string> Contents = new List<string>();
StringBuilder QueryBuilder = new StringBuilder();
QueryBuilder.AppendFormat("select * from {0} where ID in ({1}) order by ID", EntityName, ToCommaList(EntityIDs));
DataTable Table = SQLLite.GetDataTable(QueryBuilder.ToString());
for (int i=0; i < Table.Rows.Count; i++)
{
IDs.Add(Table.Rows[i][0].ToString());
Contents.Add(Table.Rows[i][1].ToString());
}
Result.Records = Contents;
Result.WantIDs = EntityIDs.Except<string>(IDs).ToList<string>();
return Result;
}
public void NoElementsAreReturnedWhenFirstIsSubsetOfSecond()
{
var first = new[] { 1, 2, 3, 4, 5 };
var second = new[] { 1, 2, 3, 4, 5, 6 };
var result = first.Except(second);
var expected = Enumerable.Empty<Int32>();
Assert.That(result, Is.EqualTo(expected));
}
public void ElementInSecondAndNotInFirstIsNotReturned()
{
var first = new[] { 1, 2, 3, 4, 5, 7 };
var second = new[] { 1, 2, 3, 4, 5, 6 };
var result = first.Except(second);
var expected = new[] { 7 };
EnumerableAssert.AssertContent(expected, result);
}
public void ElementInFirstAndNotSecondIsReturned()
{
var first = new[] { 1, 2, 3, 4, 5, 6 };
var second = new[] { 1, 2, 3, 4, 5 };
var result = first.Except(second);
var expected = new[] { 6 };
Assert.That(result, Is.EqualTo(expected));
}
public void TestMethod()
{
var doclist = new[] {
new {RelatingDocument = "Doc1", RelatedObjects = new List<string>() { "Ent1", "Ent2", "Ent3", "Ent4", "Ent5" } },
new {RelatingDocument = "Doc1", RelatedObjects = new List<string>() { "Ent1", "Ent6", "Ent7" } },
new {RelatingDocument = "Doc1", RelatedObjects = new List<string>() { "Ent8", "Ent9" } },
new {RelatingDocument = "Doc2", RelatedObjects = new List<string>() { "Ent1", "Ent6", "Ent7" } },
new {RelatingDocument = "Doc3", RelatedObjects = new List<string>() { "Ent1", "Ent6" } },
new {RelatingDocument = "Doc4", RelatedObjects = new List<string>() { "Ent1", "Ent2", "Ent7" } },
new {RelatingDocument = "Doc5", RelatedObjects = new List<string>() { "Ent1", "Ent2", "Ent3" } },
new {RelatingDocument = "Doc1", RelatedObjects = new List<string>() { "Ent10", "Ent11" } },
new {RelatingDocument = "Doc2", RelatedObjects = new List<string>() { "Ent10", "Ent11" } },
}.ToList();
Dictionary<string, List<string>> dic = null;
//check for duplicates
var dups = doclist.GroupBy(d => d.RelatingDocument).SelectMany(grp => grp.Skip(1));
//combine object lists to single key value, merge lists
var dupsMerge = dups.GroupBy(d => d.RelatingDocument).Select(p => new { x = p.Key, y = p.SelectMany(c => c.RelatedObjects) });
if (dupsMerge.Any())
{
//remove the duplicates and convert to dictionary
dic = doclist.Except(dups).ToDictionary(p => p.RelatingDocument, p => p.RelatedObjects);
//add the duplicate doc referenced object lists to the original doc
foreach (var item in dupsMerge)
{
dic[item.x] = dic[item.x].Union(item.y).ToList();
}
}
else
{
//no duplicates, so just convert to dictionary
dic = doclist.ToDictionary(p => p.RelatingDocument, p => p.RelatedObjects);
}
//reverse lookup to entity to list of documents
var newDic = dic
.SelectMany(pair => pair.Value
.Select(val => new { Key = val, Value = pair.Key }))
.GroupBy(item => item.Key)
.ToDictionary(gr => gr.Key, gr => gr.Select(item => item.Value));
Assert.AreEqual(newDic["Ent1"].Count(), 5);
Assert.AreEqual(newDic["Ent2"].Count(), 3);
Assert.AreEqual(newDic["Ent3"].Count(), 2);
Assert.AreEqual(newDic["Ent4"].Count(), 1);
Assert.AreEqual(newDic["Ent5"].Count(), 1);
Assert.AreEqual(newDic["Ent6"].Count(), 3);
Assert.AreEqual(newDic["Ent7"].Count(), 3);
Assert.AreEqual(newDic["Ent8"].Count(), 1);
Assert.AreEqual(newDic["Ent9"].Count(), 1);
Assert.AreEqual(newDic["Ent10"].Count(), 2);
Assert.AreEqual(newDic["Ent11"].Count(), 2);
}
public void Except()
{
var target = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var except = new[] { 1, 3, 5, 7, 9 };
List<int> actual = target.Except(except).ToList();
Assert.Equal(5, actual.Count);
Assert.Equal(0, actual[0]);
Assert.Equal(2, actual[1]);
Assert.Equal(4, actual[2]);
Assert.Equal(6, actual[3]);
Assert.Equal(8, actual[4]);
}
private void btnBrowseData_Click(object sender, RoutedEventArgs e) {
var dialog = new FolderBrowserDialog {
Description = "Select the directory containing the PCSX2 data folders (bios, inis, logs, memcards, snaps, sstates)"
};
if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK) return;
var first = new[] { "inis", "bios", "logs", "memcards", "snaps", "sstates" };
var second = (from d in Directory.GetDirectories(dialog.SelectedPath) select new DirectoryInfo(d).Name).ToArray();
if (first.Except(second).Any())
Legacy.Tools.ShowMessage("A required folder has not been found!", Legacy.MessageType.Error);
else
tbPcsx2DataDir.Text = dialog.SelectedPath;
}
/// <summary>
/// Attempts to fill the container with beer
/// </summary>
/// <param name="container"></param>
public void Into(ContainerObject container)
{
IEnumerable<Guid> idsForObjectsBeingHeld = _avatar.Contents.Select(x => x.ObjectId);
IEnumerable<Guid> containerObjectIds = new[] { container }.Select(x => x.ObjectId);
bool tryingToUseContainerNotBeingHeld = containerObjectIds.Except(idsForObjectsBeingHeld).Any();
if (tryingToUseContainerNotBeingHeld)
{
throw new LawsOfPhysicsViolationException("You do not have telekinesis! You need to pick the item(s) up first.");
}
_fridge.DispenseBeerInto(container);
}
private static void SeedDB()
{
var roles = new[] { "Player", "Moderator", "Admin" };
var currRoles = Roles.GetAllRoles();
foreach (var role in roles.Except(currRoles))
if (!Roles.RoleExists(role))
Roles.CreateRole(role);
if (Roles.GetUsersInRole("Admin").Length == 0)
{
Membership.CreateUser("admin", "admin123");
Roles.AddUserToRoles("admin", roles);
}
}
public static void CollectionMath_Test()
{
var arr1 = new[] {1, 2, 3, 4, 5, 6};
var arr2 = new[] {2, 9};
var test1 = arr1.Intersect(arr2);
var test2 = arr1.Union(arr2);
var test3 = arr1.Except(arr2);
Console.WriteLine(arr1.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
Console.WriteLine(arr2.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine(test1.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
Console.WriteLine(test2.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
Console.WriteLine(test3.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
}
public void FirstSequenceOnlyReadAsResultsAreRead()
{
var firstQuery = new[] { 10, 2, 0, 2 }.Select(x => 10 / x);
int[] second = { 1 };
var query = firstQuery.Except(second);
using (var iterator = query.GetEnumerator())
{
// We can get the first value with no problems
Assert.IsTrue(iterator.MoveNext());
Assert.AreEqual(5, iterator.Current);
// Getting at the *second* value of the result sequence requires
// reading from the first input sequence until the "bad" division
Assert.Throws<DivideByZeroException>(() => iterator.MoveNext());
}
}
public void TestBasicFeature()
{
var outputFolder = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "validate_bookmark");
Directory.CreateDirectory(outputFolder);
Manifest manifest = new Manifest
{
SourceBasePath = outputFolder,
Files = new List<ManifestItem>
{
new ManifestItem { SourceRelativePath = "a.md", OutputFiles = new Dictionary<string, OutputFileInfo> { { ".html", new OutputFileInfo { RelativePath = "a.html" } } } },
new ManifestItem { SourceRelativePath = "b.md", OutputFiles = new Dictionary<string, OutputFileInfo> { { ".html", new OutputFileInfo { RelativePath = "b.html" } } } },
new ManifestItem { SourceRelativePath = "c.md", OutputFiles = new Dictionary<string, OutputFileInfo> { { ".html", new OutputFileInfo { RelativePath = "c.html" } } } },
}
};
File.WriteAllText(Path.Combine(outputFolder, "a.html"), @"<a href='http://bing.com#top'>Microsoft Bing</a> <p id='b1'>section</p><a href='#b1'/>");
File.WriteAllText(Path.Combine(outputFolder, "b.html"), @"<a href='a.html#b1' sourceFile='b.md' sourceStartLineNumber='1'>bookmark existed</a><a href='a.html#b2' data-raw-source='[link with source info](a.md#b2)' sourceFile='b.md' sourceStartLineNumber='1'>link with source info</a> <a href='a.html#b3' data-raw-source='[link in token file](a.md#b3)' sourceFile='token.md' sourceStartLineNumber='1'>link in token file</a><a href='a.html#b4'>link without source info</a>");
File.WriteAllText(Path.Combine(outputFolder, "c.html"), @"<a href='illegal_path_%3Cillegal character%3E.html#b1'>Test illegal link path</a>");
Logger.RegisterListener(_listener);
using (new LoggerPhaseScope("validate_bookmark"))
{
new HtmlPostProcessor
{
Handlers = { new ValidateBookmark() }
}.Process(manifest, outputFolder);
}
Logger.UnregisterListener(_listener);
var logs = _listener.Items;
Console.WriteLine(string.Concat(logs.Select(l => Tuple.Create(l.Message, l.File))));
Assert.Equal(3, logs.Count);
var expected = new[]
{
Tuple.Create(@"Illegal link: `[link with source info](a.md#b2)` -- missing bookmark. The file a.md doesn't contain a bookmark named b2.", "b.md"),
Tuple.Create(@"Illegal link: `[link in token file](a.md#b3)` -- missing bookmark. The file a.md doesn't contain a bookmark named b3.", "token.md"),
Tuple.Create(@"Illegal link: `<a href=""a.md#b4"">link without source info</a>` -- missing bookmark. The file a.md doesn't contain a bookmark named b4.", "b.md"),
};
var actual = logs.Select(l => Tuple.Create(l.Message, l.File)).ToList();
Assert.True(!expected.Except(actual).Any() && expected.Length == actual.Count);
}
static void Main(string[] args)
{
// we need to connect to cloud
// the cloud shall act as a router
const int AtAdministration = 800;
const int AtIdentityIndex = 1000;
const int AtJoin = 1001;
// if the router is not up we ought to create one
var port = 33333;
var RouterClients = new
{
Index = default(int),
Reader = default(BinaryReader),
Writer = default(BinaryWriter),
AtIdentityIndex = default(Action<int>),
AtJoin = default(Action<int>),
AtUserInput = default(Action<int, int>),
AtMove = default(Action<int, int, int>),
}.ToListFromType();
RouterClients.Add(null);
port.ToListener(
s =>
{
//Console.WriteLine("router: client connected to router");
var Writer = new BinaryWriter(s);
var RouterClient = new
{
Index = RouterClients.Count,
Reader = new BinaryReader(s),
Writer = Writer,
AtIdentityIndex =
Writer.AsBuilder()
.Int32(AtAdministration)
.Int32(AtIdentityIndex)
.Int32()
.ToAction(),
AtJoin =
Writer.AsBuilder()
.Int32(AtAdministration)
.Int32(AtJoin)
.Int32()
.ToAction(),
AtUserInput =
Writer.AsBuilder()
.Int32(ProgramDefinition.TokenAtUserInput)
.Int32()
.Int32()
.ToAction(),
AtMove =
Writer.AsBuilder()
.Int32(ProgramDefinition.TokenAtMove)
.Int32()
.Int32()
.Int32()
.ToAction()
};
var Others = RouterClients.Except(new[] { RouterClient, null });
// 0 means server to client communication
RouterClient.AtIdentityIndex(RouterClient.Index);
lock (RouterClient)
{
RouterClients.Add(RouterClient);
foreach (var other in Others)
{
other.AtJoin(RouterClient.Index);
RouterClient.AtJoin(other.Index);
}
}
while (true)
{
var Token = RouterClient.Reader.ReadInt32();
Thread.Sleep(500);
#region AtUserInput
if (Token == ProgramDefinition.TokenAtUserInput)
{
var Parameter = RouterClient.Reader.ReadInt32();
foreach (var other in Others)
other.AtUserInput(RouterClient.Index, Parameter);
}
#endregion
#region AtMove
else if (Token == ProgramDefinition.TokenAtMove)
{
var Parameter_x = RouterClient.Reader.ReadInt32();
var Parameter_y = RouterClient.Reader.ReadInt32();
foreach (var other in Others)
other.AtMove(RouterClient.Index, Parameter_x, Parameter_y);
}
#endregion
else
{
Console.WriteLine("router: unknown token: " + Token);
}
}
}
);
var c = new TcpClient();
c.Connect(IPAddress.Loopback, port);
var a = new ProgramDefinition
{
Identity = new ProgramDefinition.EndPointIdentity()
};
Console.Title = "frame 1";
{
var Reader = new BinaryReader(c.GetStream());
var Writer = new BinaryWriter(c.GetStream());
#region AtUserInput
var AtUserInput = a.AtUserInput;
a.AtUserInput =
(sender, data) =>
{
Writer.Write((int)ProgramDefinition.TokenAtUserInput);
Writer.Write((int)data);
AtUserInput(sender, data);
};
#endregion
#region AtMove
var AtMove = a.AtMove;
a.AtMove =
(sender, x, y) =>
{
Writer.Write((int)ProgramDefinition.TokenAtMove);
Writer.Write((int)x);
Writer.Write((int)y);
AtMove(sender, x, y);
};
#endregion
var Peers = new List<ProgramDefinition.EndPointIdentity>();
0.AtDelay(
delegate
{
while (c.Connected)
{
var Token = Reader.ReadInt32();
if (Token == AtAdministration)
{
var Operation = Reader.ReadInt32();
#region AtIdentityIndex
if (Operation == AtIdentityIndex)
{
var Parameter = Reader.ReadInt32();
a.Identity.Index = Parameter;
Console.WriteLine("identity " + Parameter);
}
#endregion
#region AtJoin
else if (Operation == AtJoin)
{
var Parameter = Reader.ReadInt32();
Console.WriteLine("join " + Parameter);
Peers.Add(new ProgramDefinition.EndPointIdentity { Index = Parameter });
}
#endregion
}
#region AtUserInput
else if (Token == ProgramDefinition.TokenAtUserInput)
{
var sender = Reader.ReadInt32();
var data = Reader.ReadInt32();
AtUserInput(Peers.Single(k => k.Index == sender), (char)data);
}
#endregion
#region AtUserInput
else if (Token == ProgramDefinition.TokenAtMove)
{
var sender = Reader.ReadInt32();
var x = Reader.ReadInt32();
var y = Reader.ReadInt32();
AtMove(Peers.Single(k => k.Index == sender), x, y);
}
#endregion
else
{
// some user token
Console.WriteLine("client: unknown token: " + Token);
}
}
}
);
1000.AtInterval(
delegate
{
a.Identity.Frame++;
Console.Title = "frame " + a.Identity.Frame;
}
);
}
a.GatherUserInput();
c.Close();
}
public void Except()
{
var ints1 = new[] { 1, 2, 3, 4 };
var ints2 = new[] { 3, 4, 5, 6 };
var join = ints1.Except(ints2).ToArray();
AssertEquals(@join.Length, 2);
AssertEquals(@join[0], 1);
AssertEquals(@join[1], 2);
}
public List<int> ItensFaltantes(int[] itens)
{
var itensTotal = new[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
var result = itensTotal.Except(itens);
return result.ToList();
}
public void TestExcept() {
Func<bool> f = () => {
var a0 = new[] { 1, 2, 3, 3, 2, 1 };
var a1 = new[] { 2, 3, 3, 2 };
var r = a0.Except(a1).ToArray();
return r.Length == 1 && r[0] == 1;
};
this.Test(f, true);
}
public override DTSValidationStatus Validate()
{
bool Cancel;
if (ComponentMetaData.AreInputColumnsValid == false)
return DTSValidationStatus.VS_NEEDSNEWMETADATA;
var inputColumns = ComponentMetaData.InputCollection[0].InputColumnCollection.Cast<IDTSInputColumn100>().ToArray();
var usingFullAddressColumn = inputColumns.Any(c => c.Name.Equals(FullAddressColumnName));
if (!usingFullAddressColumn)
{
// expect address1, address2, city, state, zip
var selectedColumns = inputColumns.Select(c => c.Name);
var expectedColumns = new[]{Address1ColumnName, Address2ColumnName, CityColumnName, StateColumnName, ZipColumnName};
var neededColumns = expectedColumns.Except(selectedColumns).Where(n => !string.IsNullOrWhiteSpace(n)).ToArray();
if (neededColumns.Length > 0)
{
ComponentMetaData.FireError(0, GetType().Name, String.Format("Columns required, but not found: {0}", string.Join(",", neededColumns)), "", 0, out Cancel);
return DTSValidationStatus.VS_ISBROKEN;
}
}
var usingLocationColumn = inputColumns.Any(c => c.Name.Equals(LocationColumnName));
if (!usingLocationColumn)
{
var selectedColumns = inputColumns.Select(c => c.Name);
var expectedColumns = new[] { LatitudeColumnName, LongitudeColumnName };
var neededColumns = expectedColumns.Except(selectedColumns).Where(n => !string.IsNullOrWhiteSpace(n)).ToArray();
if (neededColumns.Length > 0)
{
ComponentMetaData.FireError(0, GetType().Name, String.Format("Columns required, but not found: {0}", string.Join(",", neededColumns)), "", 0, out Cancel);
return DTSValidationStatus.VS_ISBROKEN;
}
}
foreach (var inputColumn in inputColumns)
{
if (!IsExpectedUsageType(inputColumn.Name, inputColumn.UsageType))
{
ComponentMetaData.FireError(0, inputColumn.IdentificationString, String.Format(ErrorInvalidUsageType, inputColumn.Name), "", 0, out Cancel);
return DTSValidationStatus.VS_ISBROKEN;
}
if (!IsExpectedDataType(inputColumn.Name, inputColumn.DataType))
{
ComponentMetaData.FireError(0, inputColumn.IdentificationString, String.Format(ErrorInvalidUsageType, inputColumn.Name), "", 0, out Cancel);
return DTSValidationStatus.VS_ISBROKEN;
}
}
return base.Validate();
}
public IEnumerable<ITestCase> PropertiesAreReadWritable()
{
var testData = new[]
{
new
{
Get = new Func<GitHubTagger, string>(x => x.AccessToken),
Set = new Action<GitHubTagger, string>((x, y) => x.AccessToken = y)
},
new
{
Get = new Func<GitHubTagger, string>(x => x.Owner),
Set = new Action<GitHubTagger, string>((x, y) => x.Owner = y)
},
new
{
Get = new Func<GitHubTagger, string>(x => x.Repository),
Set = new Action<GitHubTagger, string>((x, y) => x.Repository = y)
},
new
{
Get = new Func<GitHubTagger, string>(x => x.RefOrSha),
Set = new Action<GitHubTagger, string>((x, y) => x.RefOrSha = y)
},
new
{
Get = new Func<GitHubTagger, string>(x => x.TagName),
Set = new Action<GitHubTagger, string>((x, y) => x.TagName = y)
},
new
{
Get = new Func<GitHubTagger, string>(x => x.ReleaseNotes),
Set = new Action<GitHubTagger, string>((x, y) => x.ReleaseNotes = y)
},
new
{
Get = new Func<GitHubTagger, string>(x => x.AuthorName),
Set = new Action<GitHubTagger, string>((x, y) => x.AuthorName = y)
},
new
{
Get = new Func<GitHubTagger, string>(x => x.AuthorEmail),
Set = new Action<GitHubTagger, string>((x, y) => x.AuthorEmail = y)
},
};
return TestCases.WithArgs(testData).WithAuto<GitHubTagger, string>().Create(
(data, sut, value) =>
{
data.Set(sut, value);
Assert.Equal(value, data.Get(sut));
testData.Except(new[] { data }).All(x =>
{
Assert.NotEqual(value, x.Get(sut));
return true;
});
});
}
private static void VerifyAttributes(QueryResult result)
{
var list = (IEnumerable<object>)result.Results;
IEnumerable<string> names = from DynamicJsonObject i in list.Cast<DynamicJsonObject>()
select i["Name"] as string;
var expectedNames = new[] { "App Id", "Creation Date", "Object ID", "Name", "Project", "User", "Value", "Workspace" };
Assert.AreEqual(result.TotalResultCount, list.Count());
Assert.AreEqual(expectedNames.Length, list.Count());
IEnumerable<string> complement = expectedNames.Except(names);
Assert.AreEqual(0, complement.Count());
}
protected string copyFile(IPM pm, string src, string dest, bool overwrite, Argument[] except = null)
{
if(String.IsNullOrWhiteSpace(src) || String.IsNullOrWhiteSpace(dest)) {
throw new InvalidArgumentException("The source file or the destination path argument is empty.");
}
if(except != null && except.Any(p => p.type != ArgumentType.StringDouble)) {
throw new InvalidArgumentException("Incorrect data from the 'except' argument. Define as {\"f1\", \"f2\", ...}");
}
dest = location(dest.TrimEnd());
string destDir = Path.GetDirectoryName(dest);
string destFile = Path.GetFileName(dest);
src = location(src);
string[] input = new[] { src }.ExtractFiles();
#if DEBUG
Log.Trace("Found files to copy `{0}`", String.Join(", ", input));
#endif
if(except != null) {
string path = Path.GetDirectoryName(src);
input = input.Except(except
.Where(f => !String.IsNullOrWhiteSpace((string)f.data))
.Select(f => location((string)f.data, path))
.ToArray()
.ExtractFiles()
).ToArray();
}
if(input.Length < 1) {
throw new InvalidArgumentException("The input files was not found. Check your mask and the exception list if used.");
}
copyFile(destDir, destFile, overwrite, input);
return Value.Empty;
}
