public void MemoryCounterConstructorTest4()
{
Process process = new Process();
int interval = 10000;
MemoryCounter memoryCounter = new MemoryCounter(process, interval);
var currentProcess = memoryCounter.Process;
Assert.AreEqual(currentProcess != null, true);
}
private void WriteEmptyMapping(
StringBuilder writer,
MemoryCounter memory,
Stack <ICollectionEnumerator> ancestors)
{
var str = PrefixValue("{}", ancestors);
memory.Add(str);
writer.Append(str);
}
private void WriteMappingEnd(
StringBuilder writer,
MemoryCounter memory,
Stack <ICollectionEnumerator> ancestors)
{
var str = $"\n{new String(' ', ancestors.Count * 2)}}}";
memory.Add(str);
writer.Append(str);
}
private void WriteMappingKey(
EvaluationContext context,
StringBuilder writer,
MemoryCounter memory,
EvaluationResult key,
Stack <ICollectionEnumerator> ancestors)
{
var str = PrefixValue(JsonUtility.ToString(key.ConvertToString()), ancestors, isMappingKey: true);
memory.Add(str);
writer.Append(str);
}
protected sealed override Object EvaluateCore(
EvaluationContext context,
out ResultMemory resultMemory)
{
resultMemory = null;
var items = Parameters[0].Evaluate(context);
// Array
if (items.TryGetCollectionInterface(out var collection) &&
collection is IReadOnlyArray array &&
array.Count > 0)
{
var result = new StringBuilder();
var memory = new MemoryCounter(this, context.Options.MaxMemory);
// Append the first item
var item = array[0];
var itemResult = EvaluationResult.CreateIntermediateResult(context, item);
var itemString = itemResult.ConvertToString();
memory.Add(itemString);
result.Append(itemString);
// More items?
if (array.Count > 1)
{
var separator = ",";
if (Parameters.Count > 1)
{
var separatorResult = Parameters[1].Evaluate(context);
if (separatorResult.IsPrimitive)
{
separator = separatorResult.ConvertToString();
}
}
for (var i = 1; i < array.Count; i++)
{
// Append the separator
memory.Add(separator);
result.Append(separator);
// Append the next item
var nextItem = array[i];
var nextItemResult = EvaluationResult.CreateIntermediateResult(context, nextItem);
var nextItemString = nextItemResult.ConvertToString();
memory.Add(nextItemString);
result.Append(nextItemString);
}
}
return(result.ToString());
}
public void MemoryCounterConstructorTest3()
{
Process process = new Process();
int interval = 0;
try
{
MemoryCounter memoryCounter = new MemoryCounter(process, interval);
Assert.AreEqual(true, false);
}
catch (Exception)
{
Assert.AreEqual(true, true);
}
}
private void MyWindow_Loaded(object sender, RoutedEventArgs e)
{
this.Hide();
Game.Create(this, GameType.CardsNewDB);
MyWindow.MouseMove += Game.UserActivity.MyWindow_MouseMove;
MyWindow.MediaElementMusic.MediaEnded += Game.UserActivity.MediaElementMusic_MediaEnded;
MyWindow.SizeChanged += Game.UserActivity.MyWindow_SizeChanged;
MyWindow.PreviewKeyDown += Game.UserActivity.MyWindow_PreviewKeyDown;
MyWindow.PreviewMouseDown += Game.UserActivity.PreviewMouseDown;
MyWindow.PreviewMouseUp += Game.UserActivity.PreviewMouseUp;
Game.PreviewStart();
this.Show();
mc = new MemoryCounter();
}
public void TestSimpleFileParser(string filename, long expectedCount, long expectedRepeat, bool xsb)
{
IParser parser = new SimpleFileParser(filename, xsb);
ICounter testCounter = new MemoryCounter();
parser.Parse(testCounter);
List <BigramCountValue> counts = testCounter.BigramCountList();
Assert.AreEqual(expectedCount, counts.Count);
var count = from c in counts
where c.Bigram == "the quick"
select c.Count;
Assert.AreEqual(1, count.Count());
Assert.AreEqual(expectedRepeat, count.First());
}
private void LoadContent()
{
var ReqMemory = (int)(MemoryCounter.CalculateRequiredMemoryForLevel(this) / 1_048_576);
Console.WriteLine(ReqMemory.ToString() + "Mb нужно для этого уровня");
if (!MemoryCounter.IsEnoughtMemoryForLevelLoad(this))
{
var res = MessageBox.Show("Возможно не хватит памяти (или выделяемая память ограничена версией ОС или приложения) чтобы загрузить этот уровень. " +
"При загрузке уровня игра может \"вылететь\". Продолжить все равно?",
"Слишком большой уровень",
MessageBoxButton.YesNo,
MessageBoxImage.Warning);
if (res == MessageBoxResult.No)
{
this.Abort(); return;
}
}
LoadBackground();
}
public void TestCommandLineArgsParser(string argString, long expectedValue)
{
string[] args = argString.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
IParser parser = new CommandLineTextParser(args);
ICounter testCounter = new MemoryCounter();
parser.Parse(testCounter);
List <BigramCountValue> counts = testCounter.BigramCountList();
Assert.AreEqual(7, counts.Count); // 8 bigrams added but 7 values since 1 repeats
var count = from c in counts
where c.Bigram == "the quick"
select c.Count;
Assert.AreEqual(1, count.Count());
Assert.AreEqual(expectedValue, count.First());
}
public void MemoryCounterConstructorTest()
{
Process process = new Process();
int interval = 0;
//Correct interval && correct process
try
{
MemoryCounter memoryCounter = new MemoryCounter(process, interval);
Assert.AreEqual(true, true);
}
catch (Exception)
{
Assert.AreEqual(true, false);
}
//Correct interval && null process
try
{
process = null;
MemoryCounter memoryCounter = new MemoryCounter(process, interval);
Assert.AreEqual(false, true);
}
catch (Exception)
{
Assert.AreEqual(true, true);
}
//Incorrect(minus eq 0) interval && correct process
try
{
interval = 0;
MemoryCounter memoryCounter = new MemoryCounter(process, interval);
Assert.AreEqual(false, true);
}
catch (Exception)
{
Assert.AreEqual(true, true);
}
}
public void TestMemoryCounter(string bigram, long expectedCount)
{
ICounter testCounter = new MemoryCounter();
testCounter.Add("the", "quick");
testCounter.Add("quick", "brown");
testCounter.Add("brown", "fox");
testCounter.Add("fox", "and");
testCounter.Add("and", "the");
testCounter.Add("the", "quick");
testCounter.Add("quick", "blue");
testCounter.Add("blue", "hare");
List <BigramCountValue> bigramCountList = testCounter.BigramCountList();
Assert.AreEqual(7, bigramCountList.Count); // 8 bigrams added but 7 values since 1 repeats
var targetBigramCounts = from c in bigramCountList
where c.Bigram == bigram
select c.Count;
Assert.AreEqual(1, targetBigramCounts.Count()); // there should be only one instance of this bigram count
Assert.AreEqual(expectedCount, targetBigramCounts.First());
}
private void WriteValue(
EvaluationContext context,
StringBuilder writer,
MemoryCounter memory,
EvaluationResult value,
Stack <ICollectionEnumerator> ancestors)
{
String str;
switch (value.Kind)
{
case ValueKind.Null:
str = "null";
break;
case ValueKind.Boolean:
str = (Boolean)value.Value ? "true" : "false";
break;
case ValueKind.Number:
str = value.ConvertToString();
break;
case ValueKind.String:
str = JsonUtility.ToString(value.Value);
break;
default:
str = "{}"; // The value is an object we don't know how to traverse
break;
}
str = PrefixValue(str, ancestors);
memory.Add(str);
writer.Append(str);
}
public void Dispose()
{
MemoryCounter.Dispose();
CpuCounter.Dispose();
}
protected sealed override Object EvaluateCore(
EvaluationContext context,
out ResultMemory resultMemory)
{
resultMemory = null;
var result = new StringBuilder();
var memory = new MemoryCounter(this, context.Options.MaxMemory);
var current = Parameters[0].Evaluate(context);
var ancestors = new Stack <ICollectionEnumerator>();
do
{
// Descend as much as possible
while (true)
{
// Collection
if (current.TryGetCollectionInterface(out Object collection))
{
// Array
if (collection is IReadOnlyArray array)
{
if (array.Count > 0)
{
// Write array start
WriteArrayStart(result, memory, ancestors);
// Move to first item
var enumerator = new ArrayEnumerator(context, current, array);
enumerator.MoveNext();
ancestors.Push(enumerator);
current = enumerator.Current;
}
else
{
// Write empty array
WriteEmptyArray(result, memory, ancestors);
break;
}
}
// Mapping
else if (collection is IReadOnlyObject obj)
{
if (obj.Count > 0)
{
// Write mapping start
WriteMappingStart(result, memory, ancestors);
// Move to first pair
var enumerator = new ObjectEnumerator(context, current, obj);
enumerator.MoveNext();
ancestors.Push(enumerator);
// Write mapping key
WriteMappingKey(context, result, memory, enumerator.Current.Key, ancestors);
// Move to mapping value
current = enumerator.Current.Value;
}
else
{
// Write empty mapping
WriteEmptyMapping(result, memory, ancestors);
break;
}
}
else
{
throw new NotSupportedException($"Unexpected type '{collection?.GetType().FullName}'");
}
}
// Not a collection
else
{
// Write value
WriteValue(context, result, memory, current, ancestors);
break;
}
}
// Next sibling or ancestor sibling
do
{
if (ancestors.Count > 0)
{
var parent = ancestors.Peek();
// Parent array
if (parent is ArrayEnumerator arrayEnumerator)
{
// Move to next item
if (arrayEnumerator.MoveNext())
{
current = arrayEnumerator.Current;
break;
}
// Move to parent
else
{
ancestors.Pop();
current = arrayEnumerator.Array;
// Write array end
WriteArrayEnd(result, memory, ancestors);
}
}
// Parent mapping
else if (parent is ObjectEnumerator objectEnumerator)
{
// Move to next pair
if (objectEnumerator.MoveNext())
{
// Write mapping key
WriteMappingKey(context, result, memory, objectEnumerator.Current.Key, ancestors);
// Move to mapping value
current = objectEnumerator.Current.Value;
break;
}
// Move to parent
else
{
ancestors.Pop();
current = objectEnumerator.Object;
// Write mapping end
WriteMappingEnd(result, memory, ancestors);
}
}
else
{
throw new NotSupportedException($"Unexpected type '{parent?.GetType().FullName}'");
}
}
else
{
current = null;
}
} while (current != null);
} while (current != null);
return(result.ToString());
}
/// <summary>
/// Executes provided exe file and returns the result of program using.
/// </summary>
///
/// <param name="exePath">
/// Path of exe file to run.
/// </param>
///
/// <param name="program">
/// Execunitg constraints.(like memory limit, time limit)
/// </param>
/// <param name="arguments">
///
/// </param>
///
/// <returns>
/// Detailed result of program executing.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// If any argument is null.
/// </exception>
/// <exception cref="FileNotFoundException">
/// If provided path is invalid.
/// </exception>
public static Result ExecuteWin32(string exePath, Program program, string arguments)
{
//validate arguments
ProjectHelper.ValidateNotNull(program, "program");
ProjectHelper.ValidateFileExists(exePath, "exePath");
//Set error mode, for hiding error message boxes.
SetErrorMode(0x0001 | 0x0002 | 0x0004 | 0x8000);
var result = new Result {
ProgramStatus = Status.Running
};
//create new process
using (var exeProcess = new Process())
{
exeProcess.StartInfo.RedirectStandardError = true;
exeProcess.StartInfo.RedirectStandardInput = true;
exeProcess.StartInfo.RedirectStandardOutput = true;
exeProcess.StartInfo.CreateNoWindow = true;
exeProcess.StartInfo.UseShellExecute = false;
exeProcess.StartInfo.FileName = exePath;
exeProcess.StartInfo.Arguments = arguments;
exeProcess.StartInfo.Arguments = exeProcess.StartInfo.Arguments;
//start process
var memoryCounter = new MemoryCounter(exeProcess, 20);
exeProcess.Start();
Thread.Sleep(200);
//write input data
exeProcess.StandardInput.Write(program.InputTest);
exeProcess.StandardInput.Close();
exeProcess.WaitForExit(program.TimeLimit);
if (!exeProcess.HasExited)
{
exeProcess.Kill();
result.ProgramStatus = Status.TimeLimit;
}
memoryCounter.Stop();
//get program statistic
result.Error = exeProcess.StandardError.ReadToEnd();
result.Output = exeProcess.StandardOutput.ReadToEnd();
result.TimeUsed = (int)exeProcess.TotalProcessorTime.TotalMilliseconds;
result.MemoryUsed = (int)memoryCounter.Memory / 1024;
result.Output = result.Output.Trim();
//set program status
if (result.ProgramStatus != Status.TimeLimit)
{
if (exeProcess.ExitCode != 0)
{
result.ProgramStatus = Status.Crashed;
}
else
{
if (result.MemoryUsed > program.MemoryLimit)
{
result.ProgramStatus = Status.MemoryLimit;
}
else
{
if (result.Output == program.OutputTest)
{
result.ProgramStatus = Status.Accepted;
}
else
{
result.ProgramStatus = Status.WrongAnswer;
}
}
}
}
}
return(result);
}
/// <summary>
/// Add content and settings to the UI
/// </summary>
private void LoadUi()
{
Logger.Log(LogLevel.Info, "StarterTab", "Loading UI");
// Add all servers to the list
CBServerType.Items.Clear();
foreach (string servername in _servers.Keys)
{
CBServerType.Items.Add(servername);
}
int selectedServer = Config.ReadInt("Starter", "ServerType", 0);
// check if this server id exists
if (selectedServer < CBServerType.Items.Count)
{
CBServerType.SelectedIndex = selectedServer;
}
else
{
if (CBServerType.Items.Count > 0)
{
CBServerType.SelectedIndex = 0;
}
}
LoadServer();
//Selecting a server will enable/disable the available/unavailable features
// Cache total amount of ram, set maximum values
int totalMb = Convert.ToInt32(MemoryCounter.TotalMemoryMb());
TBMaxRam.Maximum = totalMb;
TBMinRam.Maximum = totalMb;
NumMaxRam.Maximum = totalMb;
NumMinRam.Maximum = totalMb;
int minRamValue = Config.ReadInt("Starter", "MinRam", 128);
int maxRamValue = Config.ReadInt("Starter", "MaxRam", 1024);
// check for sub-zero values
if (minRamValue < 0)
{
minRamValue = 0;
}
if (maxRamValue < 0)
{
maxRamValue = 0;
}
// value should be less than maximum value
if (maxRamValue < NumMaxRam.Maximum)
{
NumMaxRam.Value = maxRamValue;
}
else
{
NumMaxRam.Value = 1024;
}
if (minRamValue < NumMinRam.Maximum)
{
NumMinRam.Value = minRamValue;
}
else
{
NumMaxRam.Value = 1024;
}
// Add options for installed java versions
CBJavaVersion.Items.Clear();
if (JavaApi.IsInstalled(JavaVersion.Jre6X32))
{
CBJavaVersion.Items.Add("Java 6 - 32 bit");
}
if (JavaApi.IsInstalled(JavaVersion.Jre6X64))
{
CBJavaVersion.Items.Add("Java 6 - 64 bit");
}
if (JavaApi.IsInstalled(JavaVersion.Jre7X32))
{
CBJavaVersion.Items.Add("Java 7 - 32 bit");
}
if (JavaApi.IsInstalled(JavaVersion.Jre7X64))
{
CBJavaVersion.Items.Add("Java 7 - 64 bit");
}
if (JavaApi.IsInstalled(JavaVersion.Jre8X32))
{
CBJavaVersion.Items.Add("Java 8 - 32 bit");
}
if (JavaApi.IsInstalled(JavaVersion.Jre8X64))
{
CBJavaVersion.Items.Add("Java 8 - 64 bit");
}
int javaType = Config.ReadInt("Starter", "JavaVersion", 0);
if (javaType < CBJavaVersion.Items.Count)
{
CBJavaVersion.SelectedIndex = javaType;
}
else
{
if (CBJavaVersion.Items.Count > 0)
{
CBJavaVersion.SelectedIndex = 0;
}
}
TxtJarFile.Text = Config.ReadString("Starter", "JarFile", "");
TxtOptArg.Text = Config.ReadString("Starter", "OptionalArguments", "");
TxtOptFlag.Text = Config.ReadString("Starter", "OptionalFlags", "");
Logger.Log(LogLevel.Info, "StarterTab", "UI Loaded");
_ready = true;
}
private static string ConstructRamLabelText(MemoryCounter counter)
{
return(counter.MemoryUsageMb + "Mb (" +
counter.MemoryUsagePct.ToString(CultureInfo.InvariantCulture).PadLeft(2, '0') +
"%)");
}
public AdjustedMemoryCounter(MemoryCounter rawCounter)
{
this.rawCounter = rawCounter;
}
