public int Eval(string args) {
string propertyName;
args = Tokenizer.Next(args, out propertyName);
SomeNode propertyNode;
if (!ReplGlobals.Current.TryGetChild(propertyName, out propertyNode)) {
throw new Exception($"Couldn't find property of name {propertyNode}.");
}
var propertyDto = propertyNode.PropertyDto;
if (!propertyDto.HasSetter) {
throw new Exception($"Property {propertyName} does not have a setter.");
}
string valueString;
Tokenizer.Next(args, out valueString);
object value = Convert.ChangeType(valueString, propertyDto.Type);
var parameters = new[] { value };
Console.WriteLine($"Invoking {propertyName} setter with params ({parameters.Join(", ")}.");
var mobDto = propertyNode.Parent.MobDto;
var result = ReplGlobals.ManagementObjectService.InvokeManagedOperationAsync(mobDto.FullName, propertyName, parameters).Result;
Console.WriteLine("Result: ");
ReplUtils.PrettyPrint(result);
return 0;
}
public void ShoudSelectIn()
{
var list = new[] {1, 2, 3, 4, 5};
var inClause = new[] {1, 5};
var resultList = list.Join(inClause, x => x, y => y, (x, y) => x);
Assert.IsTrue(inClause.SequenceEqual(resultList));
}
public void TestReadBlock()
{
var strings = new[] { "some", "new", "stuff" };
string singleString = strings.Join(Environment.NewLine);
var stringsTextReader = new StringsTextReader(strings);
var buff = new char[8];
Assert.AreEqual(8, stringsTextReader.ReadBlock(buff, 0, 8));
Assert.AreEqual(singleString.Substring(0, 8), new string(buff));
}
public void Join_JoinStrings()
{
var strings = new[]
{
"a", "b", "c"
};
Assert.Equal("a,b,c", strings.Join(","));
}
public void ReferenceOuter_ReferenceInner_ValueKey_ReferenceResult()
{
string[] outer = new [] {"0", "1", "2", "3", "4", "5", "6"};
string[] inner = new [] {"0", "1", "2", "3", "4", "5", "6"};
IEnumerable<string> result = outer.Join<string, string, int, string> (inner: inner, outerKeySelector: it => int.Parse (it), innerKeySelector: it => int.Parse (it), resultSelector: (o, i) => o);
Assert.That (result.Count (), Is.EqualTo (result.Count ()));
for (int i = 0; i < outer.Length; i++) {
Assert.That (outer [i], Is.EqualTo (result.ElementAt (i)));
}
}
public void ReferenceOuter_ReferenceInner_ReferenceKey_ReferenceResult_Comparer()
{
IEqualityComparer<string> comparer = EqualityComparer<string>.Default;
string[] outer = new [] {"0", "1", "2", "3", "4", "5", "6"};
string[] inner = new [] {"0", "1", "2", "3", "4", "5", "6"};
IEnumerable<string> result = outer.Join<string, string, string, string> (inner: inner, outerKeySelector: it => it, innerKeySelector: it => it, resultSelector: (o, i) => o, comparer: comparer);
Assert.That (result.Count (), Is.EqualTo (result.Count ()));
for (int i = 0; i < outer.Length; i++) {
Assert.That (outer [i], Is.EqualTo (result.ElementAt (i)));
}
}
public void TestRead()
{
var strings = new[] { "some", "new", "stuff" };
var stringsTextReader = new StringsTextReader(strings);
foreach (char c in strings.Join(Environment.NewLine))
{
Assert.AreEqual((int)c, stringsTextReader.Read());
}
Assert.AreEqual(-1, stringsTextReader.Read());
Assert.AreEqual(-1, stringsTextReader.Read());
Assert.AreEqual(null, stringsTextReader.ReadLine());
Assert.AreEqual(-1, stringsTextReader.Peek());
}
public void InnerSequenceIsBuffered()
{
var outer = new[] { 1, 2, 3 };
var inner = new[] { 10, 0, 2 }.Select(x => 10 / x);
var query = outer.Join(inner, x => x, y => y, (x, y) => x + y);
using (var iterator = query.GetEnumerator())
{
// Even though we could sensibly see the first element before anything
// is returned, that doesn't happen: the inner sequence is read completely
// before we start reading the outer sequence
Assert.Throws<DivideByZeroException>(() => iterator.MoveNext());
}
}
public void OuterSequenceIsStreamed()
{
var outer = new[] { 10, 0, 2 }.Select(x => 10 / x);
var inner = new[] { 1, 2, 3 };
var query = outer.Join(inner, x => x, y => y, (x, y) => x + y);
using (var iterator = query.GetEnumerator())
{
// First element is fine
Assert.IsTrue(iterator.MoveNext());
Assert.AreEqual(2, iterator.Current);
// Attempting to get to the second element causes division by 0
Assert.Throws<DivideByZeroException>(() => iterator.MoveNext());
}
}
public static string GetUserName(string name = null)
{
if (name != null)
{
string parts = name.Split(' ').Join(new[] { ".", "_" }.Rand());
return parts.ToLower();
}
else
{
switch (FakerRandom.Rand.Next(2))
{
case 0:
return new Regex(@"\W").Replace(Name.GetFirstName(), "").ToLower();
case 1:
var parts = new[] { Name.GetFirstName(), Name.GetLastName() }.Select(n => new Regex(@"\W").Replace(n, ""));
return parts.Join(new[] { ".", "_" }.Rand()).ToLower();
default: throw new ApplicationException();
}
}
}
public static void Abort(ref System.Threading.Thread thread, System.TimeSpan timeout, System.Threading.ThreadState state = System.Threading.ThreadState.Stopped)
{
//If the worker IsAlive and has the requested state.
if (thread != null && (thread.IsAlive && thread.ThreadState.HasFlag(state)))
{
//Attempt to join
if (false == thread.Join(timeout))
{
try
{
//Abort
thread.Abort();
}
catch (System.Threading.ThreadAbortException) { System.Threading.Thread.ResetAbort(); }
catch { throw; } //Cancellation not supported
}
//Reset the state of the thread to indicate success
thread = null;
}
}
public void FirstOuterMatchesLastInnerLastOuterMatchesFirstInnerSameNumberElements()
{
CustomerRec[] outer = new []
{
new CustomerRec{ name = "Prakash", custID = 98022 },
new CustomerRec{ name = "Tim", custID = 99021 },
new CustomerRec{ name = "Robert", custID = 99022 }
};
OrderRec[] inner = new []
{
new OrderRec{ orderID = 45321, custID = 99022, total = 50 },
new OrderRec{ orderID = 43421, custID = 29022, total = 20 },
new OrderRec{ orderID = 95421, custID = 98022, total = 9 }
};
JoinRec[] expected = new []
{
new JoinRec{ name = "Prakash", orderID = 95421, total = 9 },
new JoinRec{ name = "Robert", orderID = 45321, total = 50 }
};
Assert.Equal(expected, outer.Join(inner, e => e.custID, e => e.custID, createJoinRec));
}
private void JoinSample()
{
string[] names = new[] {"Robin", "Ruth", "Bob", "Emma"};
string[] colors = new[] {"Red", "Blue", "Beige", "Green"};
List<string> list = names.Join(colors, name => name[0], color => color[0], (name, color) => name + "-" + color).ToList();
System.Console.WriteLine("result sequence:");
foreach(var item in list)
System.Console.WriteLine(item);
//Func<string, int> calc = s => s.Length;
}
protected string GetCompilerDefines()
{
var defines = new[] {
"/d:Framework_4_0"
};
return defines.Join(" ");
}
public void should_join_strings()
{
var values = new[] { "a", "sequence", "of", "strings" };
values.Join(",").Should().Be("a,sequence,of,strings");
values.Join("|").Should().Be("a|sequence|of|strings");
}
public void TestReadToEnd()
{
var strings = new[] {"some", "new", "stuff"};
var stringsTextReader = new StringsTextReader(strings);
Assert.AreEqual(strings.Join(Environment.NewLine), stringsTextReader.ReadToEnd());
}
public void InnerKeySelectorNull()
{
CustomerRec[] outer = new []
{
new CustomerRec{ name = "Prakash", custID = 98022 },
new CustomerRec{ name = "Tim", custID = 99021 },
new CustomerRec{ name = "Robert", custID = 99022 }
};
AnagramRec[] inner = new []
{
new AnagramRec{ name = "miT", orderID = 43455, total = 10 },
new AnagramRec{ name = "Prakash", orderID = 323232, total = 9 }
};
Assert.Throws<ArgumentNullException>("innerKeySelector", () => outer.Join(inner, e => e.name, null, createJoinRec, new AnagramEqualityComparer()));
}
public void SkipsNullElements()
{
string[] outer = new [] { null, string.Empty };
string[] inner = new [] { null, string.Empty };
string[] expected = new [] { string.Empty };
Assert.Equal(expected, outer.Join(inner, e => e, e => e, (x, y) => y, EqualityComparer<string>.Default));
}
public void Join()
{
var ints1 = new[] { 1, 2, 3, 4 };
var ints2 = new[] { 3, 4, 5, 6 };
var join = ints1.Join(ints2, x => x, x => x, (x, y) => x + y).ToArray();
AssertEquals(@join.Length, 2);
AssertEquals(@join[0], 6);
AssertEquals(@join[1], 8);
}
public void join_lists()
{
var values = new[] { 0, 2 };
var fixtures = CreateSequentialFixtures(3);
var sut = CreateDynamicList(values);
var expected = values.Join(fixtures, x => x, x => x.Value, (x, i) => new
{
JoinValue = x,
Identifier = i.Id
}).ToList();
var result = sut.Join(fixtures, x => x, x => x.Value, (x, i) => new
{
JoinValue = x,
Identifier = i.Id
}).ToList();
Assert.Equal(expected.Count(), result.Count());
for (int i = 0; i < expected.Count; i++)
{
Assert.Equal(expected[i].Identifier, result[i].Identifier);
Assert.Equal(expected[i].JoinValue, result[i].JoinValue);
}
}
public void NullComparer()
{
CustomerRec[] outer = new []
{
new CustomerRec{ name = "Prakash", custID = 98022 },
new CustomerRec{ name = "Tim", custID = 99021 },
new CustomerRec{ name = "Robert", custID = 99022 }
};
AnagramRec[] inner = new []
{
new AnagramRec{ name = "miT", orderID = 43455, total = 10 },
new AnagramRec{ name = "Prakash", orderID = 323232, total = 9 }
};
JoinRec[] expected = new [] { new JoinRec{ name = "Prakash", orderID = 323232, total = 9 } };
Assert.Equal(expected, outer.Join(inner, e => e.name, e => e.name, createJoinRec, null));
}
public void NoMatches()
{
CustomerRec[] outer = new []
{
new CustomerRec{ name = "Prakash", custID = 98022 },
new CustomerRec{ name = "Bob", custID = 99022 },
new CustomerRec{ name = "Tim", custID = 99021 },
new CustomerRec{ name = "Robert", custID = 99022 }
};
OrderRec[] inner = new []
{
new OrderRec{ orderID = 45321, custID = 18022, total = 50 },
new OrderRec{ orderID = 43421, custID = 29022, total = 20 },
new OrderRec{ orderID = 95421, custID = 39021, total = 9 }
};
Assert.Empty(outer.Join(inner, e => e.custID, e => e.custID, createJoinRec));
}
public void OuterSameKeyMoreThanOneElementAndMatches()
{
CustomerRec[] outer = new []
{
new CustomerRec{ name = "Prakash", custID = 98022 },
new CustomerRec{ name = "Bob", custID = 99022 },
new CustomerRec{ name = "Tim", custID = 99021 },
new CustomerRec{ name = "Robert", custID = 99022 }
};
OrderRec[] inner = new []
{
new OrderRec{ orderID = 45321, custID = 98022, total = 50 },
new OrderRec{ orderID = 43421, custID = 99022, total = 20 },
new OrderRec{ orderID = 95421, custID = 99021, total = 9 }
};
JoinRec[] expected = new []
{
new JoinRec{ name = "Prakash", orderID = 45321, total = 50 },
new JoinRec{ name = "Bob", orderID = 43421, total = 20 },
new JoinRec{ name = "Tim", orderID = 95421, total = 9 },
new JoinRec{ name = "Robert", orderID = 43421, total = 20 }
};
Assert.Equal(expected, outer.Join(inner, e => e.custID, e => e.custID, createJoinRec));
}
public void SingleElementEachAndDoesntMatch()
{
CustomerRec[] outer = new [] { new CustomerRec { name = "Prakash", custID = 98922 } };
OrderRec[] inner = new [] { new OrderRec { orderID = 45321, custID = 98022, total = 50 } };
Assert.Empty(outer.Join(inner, e => e.custID, e => e.custID, createJoinRec));
}
public void SingleElementEachAndMatches()
{
CustomerRec[] outer = new [] { new CustomerRec { name = "Prakash", custID = 98022 } };
OrderRec[] inner = new [] { new OrderRec { orderID = 45321, custID = 98022, total = 50 } };
JoinRec[] expected = new [] { new JoinRec { name = "Prakash", orderID = 45321, total = 50 } };
Assert.Equal(expected, outer.Join(inner, e => e.custID, e => e.custID, createJoinRec));
}
public void OuterNonEmptyInnerEmpty()
{
CustomerRec[] outer = new []
{
new CustomerRec{ name = "Tim", custID = 43434 },
new CustomerRec{ name = "Bob", custID = 34093 }
};
OrderRec[] inner = { };
Assert.Empty(outer.Join(inner, e => e.custID, e => e.custID, createJoinRec));
}
public override void CancelDownload(System.Threading.Thread downloadThread)
{
cancel = true;
if (downloadThread != null)
{
downloadThread.Abort();
downloadThread.Join(3000);
}
}
public void SimpleJoin()
{
var outer = new[] {"apple", "banana", "orange", "pineapple", "pear"};
var inner = new[] {"paul", "adam", "alex"};
var result = outer.Join(inner,
fruit => fruit[0],
person => person[0],
(fruit, person) => person + ":" + fruit);
result.AssertSequenceEqual("adam:apple", "alex:apple", "paul:pineapple", "paul:pear");
}
public void InnerNullNoComparer()
{
CustomerRec[] outer = new[]
{
new CustomerRec{ name = "Prakash", custID = 98022 },
new CustomerRec{ name = "Tim", custID = 99021 },
new CustomerRec{ name = "Robert", custID = 99022 }
};
AnagramRec[] inner = null;
Assert.Throws<ArgumentNullException>("inner", () => outer.Join(inner, e => e.name, e => e.name, createJoinRec));
}
public void ResultSelectorNullNoComparer()
{
CustomerRec[] outer = new[]
{
new CustomerRec{ name = "Prakash", custID = 98022 },
new CustomerRec{ name = "Tim", custID = 99021 },
new CustomerRec{ name = "Robert", custID = 99022 }
};
AnagramRec[] inner = new[]
{
new AnagramRec{ name = "miT", orderID = 43455, total = 10 },
new AnagramRec{ name = "Prakash", orderID = 323232, total = 9 }
};
Assert.Throws<ArgumentNullException>("resultSelector", () => outer.Join(inner, e => e.name, e => e.name, (Func<CustomerRec, AnagramRec, JoinRec>)null));
}