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; }