private Color RandomColor(DeterministicRandom random) { return(Color.FromArgb(unchecked ((byte)random.Next()), unchecked ((byte)random.Next()), unchecked ((byte)random.Next()), unchecked ((byte)random.Next()))); }
public override BitmapPalette Create(DeterministicRandom random) { if (Colors == null) { Colors = new List <Color>(); } if (random.NextBool()) { for (int i = 1; i <= random.Next(256) + 1; i++) { Colors.Add(Color.FromScRgb( (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble())); } } else { for (int i = 1; i <= random.Next(256) + 1; i++) { Colors.Add(random.NextStaticProperty <Colors, Color>()); } } return(new BitmapPalette(Colors)); }
private void SetChildrenLayout(GridType grid, DeterministicRandom random) { int childrenCount = grid.Children.Count; //Add more rows and columns to make sure they are enough to set children layout. for (int i = 0; i < childrenCount; i++) { grid.ColumnDefinitions.Add(new ColumnDefinition()); grid.RowDefinitions.Add(new RowDefinition()); } //Set children layout foreach (UIElement item in grid.Children) { int startRow = random.Next() % grid.RowDefinitions.Count; int startColumn = random.Next() % grid.ColumnDefinitions.Count; Grid.SetColumn(item, startColumn); Grid.SetRow(item, startRow); if (random.NextBool()) { int spanColumn = random.Next() % (grid.ColumnDefinitions.Count - startColumn) + 1; Grid.SetColumnSpan(item, spanColumn); } if (random.NextBool()) { int spanRow = random.Next() % (grid.RowDefinitions.Count - startRow) + 1; Grid.SetRowSpan(item, spanRow); } } }
public override InteropBitmap Create(DeterministicRandom random) { int width = random.Next(400) + 1; int height = random.Next(400) + 1; int bytesPerPixel = (int)((Format.BitsPerPixel + 7.0) / 8.0); uint bufferSizeInBytes = (uint)(width * height * bytesPerPixel); int stride = (int)(width * bytesPerPixel); IntPtr fileHandle = CreateFileMapping(INVALID_HANDLE_VALUE, IntPtr.Zero, PAGE_READWRITE, 0, bufferSizeInBytes, null); if (fileHandle == IntPtr.Zero) { throw new InvalidOperationException("Could not create a file mapping for the Interop Bitmap"); } unsafe { IntPtr viewHandle = MapViewOfFile(fileHandle, FILE_MAP_ALL_ACCESS, 0, 0, bufferSizeInBytes); byte * pixels = (byte *)viewHandle.ToPointer(); DrawToBitmap(pixels, bufferSizeInBytes, random); UnmapViewOfFile(viewHandle); } InteropBitmap bitmap = (InteropBitmap)System.Windows.Interop.Imaging.CreateBitmapSourceFromMemorySection(fileHandle, width, height, Format, stride, 0); // store the file handle as a dependency property, so that the InteropBitmap action has access to it // and so that when the InteropBitmap is garbage collected, the handle will still be closed SafeFileHandle section = new SafeFileHandle(fileHandle, true); bitmap.SetValue(HandleProperty, section); return(bitmap); }
/// <summary> /// The values in additionalValues that correspond to button properties must be 0 or 1. /// -and- /// The number of values in additionalValues match the number of properties in stylusPointDescription minus 3. /// </summary> private int[] CreateAdditionalValues(IList <StylusPointPropertyInfo> properties, DeterministicRandom random) { if (StylusPointDescription == null) { return(null); } int arrayCount = StylusPointDescription.PropertyCount - 3; int[] additionalValues; if (arrayCount < 0) { return(null); } additionalValues = new int[arrayCount]; for (int i = 0; i < arrayCount; i++) { if (properties[i].IsButton) { additionalValues[i] = random.Next(2); } else { additionalValues[i] = random.Next(); } } return(additionalValues); }
public static List <OrderEvent> GenerateSampleOrders(DateTime date, DeterministicRandom random, ILogger logger) { var orderList = new List <OrderEvent>(); var startTime = date.Date.AddHours(9); var endTime = date.Date.AddHours(23); var currentTime = startTime; var ordernum = 0; while (currentTime < endTime) { if (random.Next(1, 101) > 55 && currentTime.Hour < 23) { orderList.Add(CreateSampleOrder( TimeSpan.FromMinutes(random.Next(15, 31)), currentTime, ordernum, random)); ordernum++; } currentTime = currentTime.AddMinutes(1); } return(orderList); }
public override GestureRecognizer Create(DeterministicRandom random) { ApplicationGesture[] allAppGestures = (ApplicationGesture[])Enum.GetValues(random.NextEnum <ApplicationGesture>().GetType()); //Get a number of gestures we will enable int gestureCount = random.Next(allAppGestures.Length - 2) + 1; ArrayList enableGesturesArrayList = new ArrayList(); //Fill the arraylist with the number of gestures we want to enable while (gestureCount > 0) { int index = random.Next(allAppGestures.Length); //If adding an AllGestures,reject it and continue to get the next gesture to add if (allAppGestures[index] == ApplicationGesture.AllGestures) { continue; } bool gestureExists = false; //Check if the appgesture is already added. if there are duplicates, API throws exception for (int i = 0; i < enableGesturesArrayList.Count; i++) { ApplicationGesture currentGesture = (ApplicationGesture)enableGesturesArrayList[i]; //Don't add something that already exists in the enableGestures list if (allAppGestures[index] == currentGesture) { gestureExists = true; break; } } //Not added so far, add and continue if (gestureExists == false) { enableGesturesArrayList.Add(allAppGestures[index]); gestureCount--; //One less thing to add } } ApplicationGesture[] applicationGestureArray = (ApplicationGesture[])enableGesturesArrayList.ToArray(random.NextEnum <ApplicationGesture>().GetType()); GestureRecognizer gestureRecognizer; if (random.NextBool()) { gestureRecognizer = new GestureRecognizer(applicationGestureArray); } else { gestureRecognizer = new GestureRecognizer(); gestureRecognizer.SetEnabledGestures(applicationGestureArray); } return(gestureRecognizer); }
public override Int32Collection Create(DeterministicRandom random) { Int32Collection col = new Int32Collection(); for (int i = 0; i < random.Next(20); i++) { col.Add(random.Next(100)); } return(col); }
public override RepeatButton Create(DeterministicRandom random) { RepeatButton repeatButton = new RepeatButton(); ApplyContentControlProperties(repeatButton); repeatButton.Delay = random.Next(1000); // Interval need > 0 repeatButton.Interval = random.Next(500) + 1; return(repeatButton); }
/// <summary> /// Create a UniformGrid. /// </summary> /// <param name="random"></param> /// <returns></returns> public override UniformGrid Create(DeterministicRandom random) { UniformGrid grid = new UniformGrid(); ApplyCommonProperties(grid, random); grid.Columns = random.Next(); grid.FirstColumn = random.Next(grid.Columns); grid.Rows = random.Next(); return(grid); }
public override WriteableBitmap Create(DeterministicRandom random) { int width = random.Next(400) + 1; int height = random.Next(400) + 1; WriteableBitmap wbmp = new WriteableBitmap(width, height, DpiX, DpiY, PixelFormat, GetPalette(PixelFormat, random)); WriteableBitmapWriter writer = WriteableBitmapWriter.CreateWriter(height, wbmp.BackBufferStride, PixelFormat); writer.SetWriteableBitmapPixels(wbmp, new Int32Rect(0, 0, width, height), random); return(wbmp); }
/// <summary> /// Create a StylusPointPropertyInfo. /// </summary> /// <param name="random"></param> /// <returns></returns> public override StylusPointPropertyInfo Create(DeterministicRandom random) { StylusPointProperty stylusPointProperty = random.NextStaticField <StylusPointProperty>(typeof(StylusPointProperties)); int minimum = random.Next(10000); int maximum = random.Next(10000) + minimum; StylusPointPropertyUnit unit = random.NextEnum <StylusPointPropertyUnit>(); float resolution = random.Next(100) / 10f; StylusPointPropertyInfo stylusPointPropertyInfo = new StylusPointPropertyInfo(stylusPointProperty, minimum, maximum, unit, resolution); return(stylusPointPropertyInfo); }
/// <summary> /// Creates a new Window with random size, position, style, and background. /// Currently only used to create an Owner window for the window we are started with. /// </summary> public override Window Create(DeterministicRandom random) { Window window = new Window(); window.Top = random.Next((int)(SystemParameters.PrimaryScreenHeight * 0.8)); window.Left = random.Next((int)(SystemParameters.PrimaryScreenWidth * 0.8)); window.Height = random.Next((int)(SystemParameters.PrimaryScreenHeight * 0.4)); window.Width = random.Next((int)(SystemParameters.PrimaryScreenWidth * 0.4)); window.WindowStyle = random.NextEnum <WindowStyle>(); window.Background = Brush; window.Show(); return(window); }
private MeshGeometry3D CreateCylinder(DeterministicRandom random) { int thetaDiv = random.Next(40) + 10; int yDiv = random.Next(40) + 10; double radius = random.NextDouble() * 20 + 1.0; double maxTheta = DegreeToRadian(360.0); double maxY = random.Next(10) + 1; double minY = -1 * maxY; double dt = maxTheta / thetaDiv; double dy = (maxY - minY) / yDiv; MeshGeometry3D mesh = new MeshGeometry3D(); for (int yi = 0; yi <= yDiv; yi++) { double y = minY + yi * dy; for (int ti = 0; ti <= thetaDiv; ti++) { double theta = ti * dt; mesh.Positions.Add(GetCylinderVertexPosition(theta, y, radius)); mesh.Normals.Add((Vector3D)GetCylinderVertexPosition(theta, 0, 1.0)); mesh.TextureCoordinates.Add(new Point(random.NextDouble(), random.NextDouble())); } } for (int yi = 0; yi < yDiv; yi++) { for (int ti = 0; ti < thetaDiv; ti++) { int x0 = ti; int x1 = (ti + 1); int y0 = yi * (thetaDiv + 1); int y1 = (yi + 1) * (thetaDiv + 1); mesh.TriangleIndices.Add(x0 + y0); mesh.TriangleIndices.Add(x0 + y1); mesh.TriangleIndices.Add(x1 + y0); mesh.TriangleIndices.Add(x1 + y0); mesh.TriangleIndices.Add(x0 + y1); mesh.TriangleIndices.Add(x1 + y1); } } return(mesh); }
public bool CheckOrder(Order order) { if (!Busy) { if (OrdersDone > 15) { if (OrdersDone > 30) { ForgotToTake = rnd.Next(0, 25) != 0; } else { ForgotToTake = rnd.Next(0, 4) != 0; } } else { ForgotToTake = rnd.Next(0, 2) == 0; } if (!ForgotToTake) { if (order.State == "Is Waiting To Be Cooked") { if (!order.TakenToCook) { _logger.Log($"Pizzamaker number {PizzamakerNum} Took Order number{order.OrderNumber} "); order.TakenToCook = true; Busy = true; order.OrderTakenForCookingTime = order.CurrentTime; return(true); } } } } else { if (order.CurrentTime != order.OrderTakenForCookingTime + order.TimeToCook) { return(false); } Busy = false; OrdersDone++; _logger.Log($"Pizzamaker number {PizzamakerNum} is free."); return(true); } return(false); }
private unsafe void DrawToBitmap(byte *buffer, uint size, DeterministicRandom random) { for (uint i = 0; i < size; i++) { buffer[i] = unchecked ((byte)random.Next()); } }
private void SetChildrenLayout(Canvas canvas, DeterministicRandom random) { foreach (UIElement item in canvas.Children) { switch (random.Next() % 4) { case 0: Canvas.SetLeft(item, (random.NextDouble() - 0.5) * canvas.ActualWidth * 2); Canvas.SetBottom(item, (random.NextDouble() - 0.5) * canvas.ActualHeight * 2); break; case 1: Canvas.SetLeft(item, (random.NextDouble() - 0.5) * canvas.ActualWidth * 2); Canvas.SetTop(item, (random.NextDouble() - 0.5) * canvas.ActualHeight * 2); break; case 2: Canvas.SetRight(item, (random.NextDouble() - 0.5) * canvas.ActualWidth * 2); Canvas.SetBottom(item, (random.NextDouble() - 0.5) * canvas.ActualHeight * 2); break; case 3: Canvas.SetRight(item, (random.NextDouble() - 0.5) * canvas.ActualWidth * 2); Canvas.SetTop(item, (random.NextDouble() - 0.5) * canvas.ActualHeight * 2); break; } } }
public override MeshGeometry3D Create(DeterministicRandom random) { MeshGeometry3D mesh = new MeshGeometry3D(); switch (random.Next(5)) { case 0: mesh = CreatePlane(random); break; case 1: mesh = CreatePyramid(random); break; case 2: mesh = CreateCube(random); break; case 3: mesh = CreateSphere(random); break; case 4: mesh = CreateCylinder(random); break; default: goto case 0; } return(mesh); }
private static object MakeList(Type consumedType, ConvenienceStressState state, DeterministicRandom random, int recursionDepth, int minListSize, int maxListSize) { //The Stress consumer is asking for a list of objects. This is a bit of a complicated topic. Refer to: //Reflecting on Generics - This explains how I am identifying List Generic //http://cc.msnscache.com/cache.aspx?q=72938808547333&mkt=en-US&lang=en-US&w=d704070d&FORM=CVRE7 // //From there, we need to create an instance of the requested generic, as explained here. //http://www.codeproject.com/KB/cs/ReflectGenerics.aspx //The type of objects instantiated in the list is instanceType: Type[] genericArguments = consumedType.GetGenericArguments(); Type instanceType = genericArguments[0]; //Prepare our List object list = Activator.CreateInstance(consumedType, 1); //Create a single element array as payload for adding objects to list via reflection object[] methodCallPayload = new object[1]; int count = random.Next(maxListSize - minListSize) + minListSize; for (int i = 0; i < count; i++) { //We produce an item from a differently selected factory each time. methodCallPayload[0] = MakeItem(instanceType, state, random, recursionDepth); consumedType.InvokeMember("Add", BindingFlags.InvokeMethod, null, list, methodCallPayload); } return(list); }
/// <summary> /// Create a Uri using one of the files specified in ListOfFilesOnFileHost.xml. /// For Uris created with different files, modify ListOfFilesOnFileHost.xml. /// </summary> /// <param name="random"></param> /// <returns></returns> public override Uri Create(DeterministicRandom random) { XmlDocument document = new XmlDocument(); document.Load(filesOnFileHost); XmlNodeList files = document.GetElementsByTagName("File"); int fileCount = files.Count; if (fileCount == 0) { throw new InvalidOperationException(String.Format("File: {0} doesn't contain any File node.", filesOnFileHost)); } int fileIndex = random.Next(fileCount); XmlElement fileNode = files[fileIndex] as XmlElement; string filename = fileNode.GetAttribute("Name"); if (String.IsNullOrEmpty(filename)) { throw new InvalidOperationException(String.Format("File node : \n {0} doesn't have Name attribute.", fileNode.OuterXml)); } FileHost fileHost = new FileHost(); Uri uri = fileHost.GetUri(filename, Scheme); return(uri); }
public override DispatcherOperation Create(DeterministicRandom random) { DispatcherPriority priority = ChooseValidPriority(PriorityValue); DispatcherOperation operation = null; switch (InvokeCallbackType) { case InvokeCallbackTypes.DispatcherOperationCallback: operation = Dispatcher.BeginInvoke(priority, new DispatcherOperationCallback(DispatcherOperationCallbackMethod), this); break; case InvokeCallbackTypes.SendOrPostCallback: operation = Dispatcher.BeginInvoke(priority, new SendOrPostCallback(SendOrPostMethod), this); break; case InvokeCallbackTypes.OneParamGeneric: operation = Dispatcher.BeginInvoke(priority, new OneParamGeneric(OneParamMethod), this); break; case InvokeCallbackTypes.TwoParamGeneric: operation = Dispatcher.BeginInvoke(priority, new TwoParamGeneric(TwoParamMethod), this, new object()); break; case InvokeCallbackTypes.ThreeParamGeneric: operation = Dispatcher.BeginInvoke(priority, new ThreeParamGeneric(ThreeParamMethod), this, new object(), new object()); break; case InvokeCallbackTypes.ZeroParamGeneric: operation = Dispatcher.BeginInvoke(priority, new ZeroParamGeneric(ZeroParamMethod)); break; } operation.Aborted += new EventHandler(OperationAborted); operation.Completed += new EventHandler(OperationCompleted); //Save the DispatcherOperation, Some combinations of actions need do on the same DispatcherOperation. lock (DispatcherOperations) { DispatcherOperations.Add(operation); if (DispatcherOperations.Count > 10) { DispatcherOperations.RemoveAt(random.Next(DispatcherOperations.Count)); } return(DispatcherOperations[random.Next(DispatcherOperations.Count)]); } }
private MeshGeometry3D CreateSphere(DeterministicRandom random) { int thetaDiv = random.Next(80) + 20; int phiDiv = random.Next(40) + 10; double radius = random.NextDouble() * 20 + 1.0; double divTheta = DegreeToRadian(360.0) / thetaDiv; double divPhi = DegreeToRadian(180.0) / phiDiv; MeshGeometry3D mesh = new MeshGeometry3D(); for (int pi = 0; pi <= phiDiv; pi++) { double phi = pi * divPhi; for (int ti = 0; ti <= thetaDiv; ti++) { double theta = ti * divTheta; mesh.Positions.Add(GetSphereVertexPosition(theta, phi, radius)); mesh.Normals.Add((Vector3D)GetSphereVertexPosition(theta, phi, 1.0)); mesh.TextureCoordinates.Add(new Point(random.NextDouble(), random.NextDouble())); } } for (int pi = 0; pi < phiDiv; pi++) { for (int ti = 0; ti < thetaDiv; ti++) { int x0 = ti; int x1 = (ti + 1); int y0 = pi * (thetaDiv + 1); int y1 = (pi + 1) * (thetaDiv + 1); mesh.TriangleIndices.Add(x0 + y0); mesh.TriangleIndices.Add(x0 + y1); mesh.TriangleIndices.Add(x1 + y0); mesh.TriangleIndices.Add(x1 + y0); mesh.TriangleIndices.Add(x0 + y1); mesh.TriangleIndices.Add(x1 + y1); } } return(mesh); }
/// <summary> /// Apply common Selector properties. /// </summary> /// <param name="selector"></param> /// <param name="random"></param> protected void ApplySelectorProperties(T selector, DeterministicRandom random) { ApplyItemsControlProperties(selector, random); selector.IsSynchronizedWithCurrentItem = random.NextBool(); selector.SelectedIndex = random.Next(selector.Items.Count); selector.SelectedItem = SelectedItem; selector.SelectedValue = SelectedValue; }
/// <summary> /// Apply common TextBox properties. /// </summary> /// <param name="textBox"></param> /// <param name="random"></param> protected void ApplyTextBoxProperties(TextBoxType textBox, DeterministicRandom random) { ApplyTextBoxBaseProperties(textBox, random); textBox.MinLines = MinLines; textBox.MaxLines = MinLines + random.Next(50); textBox.MaxLength = MaxLength; textBox.Text = Text; }
public override DispatcherTimer Create(DeterministicRandom random) { //DispatcherTimer timer = null; DispatcherPriority priority = ChooseValidPriority(PriorityValue); switch (DispatcherTimerConstructorType % 4) { case 0: timer = new DispatcherTimer(); timer.Tick += new EventHandler(DispatcherTimerTick); timer.Interval = TimeSpan; break; case 1: timer = new DispatcherTimer(priority); timer.Tick += new EventHandler(DispatcherTimerTick); timer.Interval = TimeSpan; break; case 2: timer = new DispatcherTimer(priority, Dispatcher); timer.Tick += new EventHandler(DispatcherTimerTick); timer.Interval = TimeSpan; break; case 3: timer = new DispatcherTimer(TimeSpan, priority, new EventHandler(DispatcherTimerTick), Dispatcher); break; } //Save the DispatcherTimer, Some combinations of actions need do on the same DispatcherTimer. lock (DispatcherTimers) { DispatcherTimers.Add(timer); if (DispatcherTimers.Count > 10) { int removeIndex = random.Next(DispatcherTimers.Count); DispatcherTimer removeTimer = DispatcherTimers[removeIndex]; //Stop the DispatcherTimer before remove it. removeTimer.Stop(); DispatcherTimers.Remove(removeTimer); } return(DispatcherTimers[random.Next(DispatcherTimers.Count)]); } }
public Library(double revision, DeterministicRandom random) { int books = random.Next(10); for (int i = 0; i < books; i++) { Add(new Book(i + revision, random)); } }
public override void SetWriteableBitmapPixels(WriteableBitmap wbmp, Int32Rect rect, DeterministicRandom random) { for (int i = 0; i < pixels.Length; i++) { pixels[i] = unchecked ((byte)random.Next()); } wbmp.WritePixels(rect, pixels, strideInBytes, rect.X, rect.Y); }
public override CroppedBitmap Create(DeterministicRandom random) { int maxX = BitmapSource.PixelWidth; int maxY = BitmapSource.PixelHeight; int width = random.Next(maxX) + 1; int height = random.Next(maxY) + 1; int x = maxX - width; int y = maxY - height; CroppedBitmap croppedBitmap = new CroppedBitmap(); croppedBitmap.BeginInit(); croppedBitmap.Source = BitmapSource; croppedBitmap.SourceRect = new Int32Rect(x, y, width, height); croppedBitmap.EndInit(); croppedBitmap.Freeze(); return(croppedBitmap); }
public override PrintDialog Create(DeterministicRandom random) { PrintDialog printDialog = new PrintDialog(); printDialog.MinPage = (uint)MinPage; printDialog.MaxPage = (uint)(MinPage + random.Next(10)); printDialog.PageRangeSelection = random.NextEnum <PageRangeSelection>(); printDialog.UserPageRangeEnabled = random.NextBool(); return(printDialog); }
Double[] CreateAxisLines(DeterministicRandom random) { int size = random.Next(10); Double[] axisline = new Double[size]; for (int i = 0; i < size; i++) { axisline[i] = random.NextDouble() * 10; } return(axisline); }