public void SortingTest()
{
Action<int[]>[] actions = new Action<int[]>[]
{
BubbleSort.Sort,
data => BucketSort.Sort(data, SortingTests.MaxValue),
data => CountingSort.Sort(data, SortingTests.MaxValue),
HeapSort.Sort,
InsertionSort.Sort,
MergeSort.Sort,
QuickSort.Sort,
data => RadixSort.Sort(data, SortingTests.MaxValue),
};
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 100; j++)
{
int[] data = ArrayUtilities.CreateRandomArray(j, 0, SortingTests.MaxValue);
int[][] results = new int[actions.Length][];
for (int k = 0; k < actions.Length; k++)
{
results[k] = new int[data.Length];
Array.Copy(data, results[k], data.Length);
actions[k](results[k]);
Assert.IsTrue(ArrayUtilities.AreEqual(results[k], results[0]));
}
}
}
} public void SortedMergeTest()
{
Action<int[], int[]>[] actions = new Action<int[], int[]>[]
{
SortedMerge.BruteForce,
SortedMerge.SinglePass
};
for(int i = 0; i < 10; i++)
{
int[] A = ArrayUtilities.CreateRandomArray(40, 0, 20);
int[] B = ArrayUtilities.CreateRandomArray(20, 0, 20);
Array.Sort(A, 0, A.Length / 2);
Array.Sort(B);
int[][] results = new int[actions.Length][];
for(int j = 0; j < actions.Length; j++)
{
results[j] = new int[A.Length];
Array.Copy(A, results[j], A.Length);
int[] copyB = new int[B.Length];
Array.Copy(B, copyB, B.Length);
actions[j](results[j], copyB);
Assert.IsTrue(ArrayUtilities.AreEqual(results[0], results[j]));
}
}
} /// <summary>
/// Creates a new menu form.
/// </summary>
/// <param name="title">Window title.</param>
/// <param name="itemNames">Item names.</param>
/// <param name="actions">Actions.</param>
public MenuForm(string title, string[] itemNames, Action[] actions)
{
Title = title;
SelectedIndex = -1;
if (itemNames == null || actions == null)
return;
if (itemNames.Length != actions.Length)
return;
var stackLayout = new StackLayout {Orientation = Orientation.Vertical, HorizontalContentAlignment = HorizontalAlignment.Stretch };
for (int i = 0; i < itemNames.Length; i++)
{
var idx = i;
var button = new Button { Text = itemNames[idx], Size = new Size(240, 60) };
button.Click += (s, e) =>
{
actions[idx]();
SelectedIndex = idx;
this.Close();
};
stackLayout.Items.Add(new StackLayoutItem(button, true));
}
Content = stackLayout;
Size = new Size(-1, -1);
} public void IncrementIntegerTest()
{
Action<List<int>>[] actions = new Action<List<int>>[]
{
IncrementInteger.Convert,
IncrementInteger.SinglePass
};
int digits = 0;
for (int i = 0; i <= 1000; i++)
{
if (i % 10 == 0)
digits++;
for(int j = 0; j < actions.Length; j++)
{
List<int> list = new List<int>();
for (int k = 0; k < digits; k++)
list.Insert(0, 0);
IncrementInteger.ToList(i, list);
actions[j](list);
Assert.AreEqual(IncrementInteger.ToInt(list), i + 1);
}
}
} /// <summary>
/// Enumerates the segments in a path and calls a corresponding delegate verifier on each segment.
/// Do not overuse this method: most test cases don't need to over-baseline what the expected segments are.
/// </summary>
public static void VerifyPath(ODataPath path, Action<ODataPathSegment>[] segmentVerifiers)
{
path.Count().Should().Be(segmentVerifiers.Count());
var i = 0;
foreach (var segment in path)
{
segmentVerifiers[i++](segment);
}
} public static void ProcessMovieImport(string fn, Action<string> conversionErrorCallback, Action<string> messageCallback)
{
var d = PathManager.MakeAbsolutePath(Global.Config.PathEntries.MoviesPathFragment, null);
string errorMsg;
string warningMsg;
var m = ImportFile(fn, out errorMsg, out warningMsg);
if (!string.IsNullOrWhiteSpace(errorMsg))
{
conversionErrorCallback(errorMsg);
}
if (!string.IsNullOrWhiteSpace(warningMsg))
{
messageCallback(warningMsg);
}
else
{
messageCallback(Path.GetFileName(fn) + " imported as " + m.Filename);
}
if (!Directory.Exists(d))
{
Directory.CreateDirectory(d);
}
} /// <summary>
/// Sets the delegate to use when configuring the application's <see cref="GlobalConfiguration.Configuration"/>.
/// </summary>
/// <param name="configurationDelegate">The configuration delegate.</param>
/// <returns>Current <see cref="WebApiManagerBuilder"/> instance.</returns>
/// <remarks></remarks>
public ApplicationConfigurationBuilder ConfigureForIIS(Action<HttpConfiguration> configurationDelegate)
{
_AspNetHttpConfigurationDelegate = configurationDelegate;
Setup();
return Builder;
} public static void Invoke(this Control uiElement, Action updater, bool forceSynchronous = true)
{
if (uiElement == null)
{
throw new ArgumentNullException("uiElement");
}
if (uiElement.InvokeRequired)
{
if (forceSynchronous)
{
try
{
uiElement.Invoke((Action)delegate { Invoke(uiElement, updater, forceSynchronous); });
}
catch (Exception e) { }
}
else
{
uiElement.BeginInvoke((Action)delegate { Invoke(uiElement, updater, forceSynchronous); });
}
}
else
{
if (!uiElement.IsDisposed)
{
updater();
}
}
} public UpdateHandler(DataTrade trade, DataFeed feed, Action<SymbolInfo[], AccountInfo, Quote> updateCallback, Processor processor)
{
if (trade == null)
throw new ArgumentNullException(nameof(trade));
if (feed == null)
throw new ArgumentNullException(nameof(feed));
if (updateCallback == null)
throw new ArgumentNullException(nameof(updateCallback));
if (processor == null)
throw new ArgumentNullException(nameof(processor));
this.updateCallback = updateCallback;
this.processor = processor;
this.SyncRoot = new object();
feed.SymbolInfo += this.OnSymbolInfo;
feed.Tick += this.OnTick;
trade.AccountInfo += this.OnAccountInfo;
trade.BalanceOperation += this.OnBalanceOperation;
trade.ExecutionReport += this.OnExecutionReport;
trade.PositionReport += this.OnPositionReport;
} //public async Task<string> WebMethod2()
public void WebMethod2(Action<string> yield)
{
// ThreadLocal SynchronizationContext aware ConnectionPool?
var n = new PerformanceResourceTimingData2ApplicationPerformance();
var rid = n.Insert(
new PerformanceResourceTimingData2ApplicationPerformanceRow
{
connectStart = 5,
connectEnd = 13,
// conversion done in AddParameter
// .stack rewriter needs to store struct. can we create new byref struct parameters?
//EventTime = DateTime.Now.AddDays(-0),
// conversion done in Insert?
z = new XElement("goo", "foo")
}
);
// { LastInsertRowId = 2 }
Console.WriteLine("after insert " + new { rid });
var c = new PerformanceResourceTimingData2ApplicationPerformance().Count();
Console.WriteLine(new { c, rid });
// I/System.Console( 7320): {{ c = 18, rid = 18 }}
//return new { c, rid }.ToString();
yield(
"TestAndroidInsert " + new { c, rid }.ToString()
);
} public static void CreateTchatCommand(string name, string help, Action<string[], Bot> action)
{
string commandName = name.ToLowerInvariant();
if (m_commands.Count(entry => entry.CommandName == commandName) == 1)
throw new InvalidOperationException(String.Format("Command {0} already exists.", name));
m_commands.Add(new TchatCommand(name, help, action));
} /// <summary>
/// Adds a saved search to your twitter account
/// </summary>
/// <param name="query">Search query to add</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>SavedSearch object</returns>
public static SavedSearch CreateSavedSearch(this TwitterContext ctx, string query, Action<TwitterAsyncResponse<SavedSearch>> callback)
{
if (string.IsNullOrEmpty(query))
{
throw new ArgumentException("query is required.", "query");
}
var savedSearchUrl = ctx.BaseUrl + "saved_searches/create.json";
var reqProc = new SavedSearchRequestProcessor<SavedSearch>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostToTwitter(
savedSearchUrl,
new Dictionary<string, string>
{
{ "query", query }
},
response => reqProc.ProcessActionResult(response, SavedSearchAction.Create));
SavedSearch result = reqProc.ProcessActionResult(resultsJson, SavedSearchAction.Create);
return result;
} public override void AnalyzeSymbol(INamedTypeSymbol symbol, Compilation compilation, Action<Diagnostic> addDiagnostic, CancellationToken cancellationToken)
{
if (symbol.TypeKind != TypeKind.Enum)
{
return;
}
var flagsAttribute = WellKnownTypes.FlagsAttribute(compilation);
if (flagsAttribute == null)
{
return;
}
var zeroValuedFields = GetZeroValuedFields(symbol).ToImmutableArray();
bool hasFlagsAttribute = symbol.GetAttributes().Any(a => a.AttributeClass == flagsAttribute);
if (hasFlagsAttribute)
{
CheckFlags(symbol, zeroValuedFields, addDiagnostic);
}
else
{
CheckNonFlags(symbol, zeroValuedFields, addDiagnostic);
}
} public static SplitterBuilder VnrSplitter(this HtmlHelper helper, SplitterBuilderInfo builderInfo)
{
var pane = new Action<SplitterPaneFactory>(p =>
{
foreach (var item in builderInfo.Panes)
{
if (!string.IsNullOrWhiteSpace(item.Value.Content))
{
p.Add()
.Content(item.Value.Content)
.Collapsible(item.Value.Collapsible)
.Scrollable(item.Value.Scrollable)
.Size(item.Value.Size)
.Resizable(item.Value.Resizable);
}
else if (!string.IsNullOrEmpty(item.Value.Controller) || !string.IsNullOrEmpty(item.Value.ActionName))
{
p.Add()
.LoadContentFrom(item.Value.ActionName, item.Value.Controller)
.Collapsible(item.Value.Collapsible)
.Scrollable(item.Value.Scrollable)
.Size(item.Value.Size)
.Resizable(item.Value.Resizable);
}
}
});
var splitterBuilder = helper.Kendo().Splitter()
.Orientation(builderInfo.Orientation)
.Name(builderInfo.Name)
.HtmlAttributes(new {style="height:"+builderInfo.Height+"px;"})
.Panes(pane);
return splitterBuilder;
} public EventSignal<IResponse> PostAsync(string url, Action<IRequest> prepareRequest, Dictionary<string, string> postData)
{
var returnSignal = new EventSignal<IResponse>();
var signal = HttpHelper.PostAsync(url, request => prepareRequest(new HttpWebRequestWrapper(request)), postData);
signal.Finished += (sender, e) => returnSignal.OnFinish(new HttpWebResponseWrapper(e.Result.Result) { Exception = e.Result.Exception, IsFaulted = e.Result.IsFaulted });
return returnSignal;
} /// <summary>
/// Repeats the specified <see cref="Action"/> the number of times.
/// </summary>
/// <param name="input">The number of times to repeat the <see cref="Action"/>.</param>
/// <param name="action">The <see cref="Action"/> to repeat.</param>
public static void Times(this int input, Action action)
{
while (input-- > 0)
{
action();
}
} private void Configure(AzureServiceBusOwinServiceConfiguration config, Action<IAppBuilder> startup)
{
if (startup == null)
{
throw new ArgumentNullException("startup");
}
var options = new StartOptions();
if (string.IsNullOrWhiteSpace(options.AppStartup))
{
// Populate AppStartup for use in host.AppName
options.AppStartup = startup.Method.ReflectedType.FullName;
}
var testServerFactory = new AzureServiceBusOwinServerFactory(config);
var services = ServicesFactory.Create();
var engine = services.GetService<IHostingEngine>();
var context = new StartContext(options)
{
ServerFactory = new ServerFactoryAdapter(testServerFactory),
Startup = startup
};
_started = engine.Start(context);
_next = testServerFactory.Invoke;
} /// <summary>
/// Add a new timer and starts measuring time.
/// </summary>
/// <param name="duration">When the action must be started.</param>
/// <param name="callbackAction">Action to invoke on time.</param>
/// <param name="removeAfterCallback">Remove timer from list after execution of callback.</param>
/// <returns>Timer instance.</returns>
public Timer AddTimer(double duration, Action callbackAction, bool removeAfterCallback = false)
{
var timer = new Timer(duration, callbackAction, removeAfterCallback) {Running = true};
timers.Add(timer);
return timer;
} /// <inheritdoc/>
public override void Init(NLite.Mini.Activation.IActivator activator, IKernel kernel, IComponentInfo info, Action<IComponentInfo, object> onDestroying, Action<IComponentContext> onFetch)
{
Guard.NotNull(activator, "activator");
Guard.NotNull(kernel, "kernel");
Guard.NotNull(info, "info");
Real.Init(new ProxyActivator(activator), kernel, info, onDestroying,OnFetch);
} public MyCubeGridSystems(MyCubeGrid grid)
{
m_cubeGrid = grid;
m_terminalSystem_GroupAdded = TerminalSystem_GroupAdded;
m_terminalSystem_GroupRemoved = TerminalSystem_GroupRemoved;
GyroSystem = new MyGridGyroSystem(m_cubeGrid);
WeaponSystem = new MyGridWeaponSystem();
ReflectorLightSystem = new MyGridReflectorLightSystem(m_cubeGrid);
if (MyFakes.ENABLE_WHEEL_CONTROLS_IN_COCKPIT)
{
WheelSystem = new MyGridWheelSystem(m_cubeGrid);
}
ConveyorSystem = new MyGridConveyorSystem(m_cubeGrid);
LandingSystem = new MyGridLandingSystem();
ControlSystem = new MyGroupControlSystem();
CameraSystem = new MyGridCameraSystem(m_cubeGrid);
if (MySession.Static.Settings.EnableOxygen)
{
GasSystem = new MyGridGasSystem(m_cubeGrid);
}
if (MyPerGameSettings.EnableJumpDrive)
{
JumpSystem = new MyGridJumpDriveSystem(m_cubeGrid);
}
if (MyPerGameSettings.EnableShipSoundSystem && (MyFakes.ENABLE_NEW_SMALL_SHIP_SOUNDS || MyFakes.ENABLE_NEW_LARGE_SHIP_SOUNDS) && MySandboxGame.IsDedicated == false)
{
ShipSoundComponent = new MyShipSoundComponent();
}
m_blocksRegistered = true;
} /// <summary>
/// Creates a new command.
/// </summary>
/// <param name="execute">The execution logic.</param>
/// <param name="canExecute">The execution status logic.</param>
public RelayCommand(Action<object> execute, Func<bool> canExecute)
{
if (execute == null)
throw new ArgumentNullException("execute");
_execute = execute;
_canExecute = canExecute;
} public static String CaptureOutput(Action Action, bool Capture = true)
{
if (Capture)
{
var OldOut = Console.Out;
var StringWriter = new StringWriter();
try
{
Console.SetOut(StringWriter);
Action();
}
finally
{
Console.SetOut(OldOut);
}
try
{
return StringWriter.ToString();
}
catch
{
return "";
}
}
else
{
Action();
return "";
}
} public void GetData(Action<DataItem, Exception> callback)
{
// Use this to create design time data
var item = new DataItem("Welcome to MVVM Light [design]");
callback(item, null);
} public void BackupDataBase(string destinationPath, Action<int> percentCompleteCallback, Action completeCallback)
{
var server = GetDbServer();
var backup = new Backup();
backup.Action = BackupActionType.Database;
backup.Database = this.DatabaseName;
backup.Devices.Add(new BackupDeviceItem(GetFileName(destinationPath, this.DatabaseName, ".bak"), DeviceType.File));
backup.Initialize = true;
backup.Checksum = true;
backup.ContinueAfterError = true;
backup.Incremental = false;
backup.PercentCompleteNotification = 1;
backup.LogTruncation = BackupTruncateLogType.Truncate;
backup.Complete += (s, e) =>
{
if (completeCallback != null)
{
completeCallback();
}
};
backup.PercentComplete += (s, e) =>
{
if (percentCompleteCallback != null)
{
percentCompleteCallback(e.Percent);
}
};
backup.SqlBackupAsync(server);
} public SmugglerApi(SmugglerOptions smugglerOptions, IAsyncDatabaseCommands commands, Action<string> output)
: base(smugglerOptions)
{
this.commands = commands;
this.output = output;
batch = new List<RavenJObject>();
} public override void Connect(string host, int port, Action callback)
{
if (state != Socket.SocketState.Invalid)
throw new InvalidOperationException ("Socket already in use");
int error;
var fd = manos_socket_connect (host, port, out error);
if (fd < 0)
throw new Exception (String.Format ("An error occurred while trying to connect to {0}:{1} errno: {2}", host, port, error));
stream = new PlainSocketStream (this, new IntPtr (fd));
var connectWatcher = new IOWatcher (new IntPtr (fd), EventTypes.Write, Context.Loop, (watcher, revents) => {
watcher.Stop ();
watcher.Dispose ();
this.address = host;
this.port = port;
this.state = Socket.SocketState.Open;
callback ();
});
connectWatcher.Start ();
} public AppUpdateControl(IEnumerable<IAppVersion> appVersions, Action<IAppVersion> updateAction)
{
this.NewestVersion = appVersions.First();
InitializeComponent();
this.AppIconImage.ImageFailed += (sender, e) => { this.AppIconImage.Source = new BitmapImage(new Uri("/Assets/windows_phone.png", UriKind.RelativeOrAbsolute)); };
this.AppIconImage.Source = new BitmapImage(new Uri(HockeyClient.Current.AsInternal().ApiBaseVersion2 + "apps/" + NewestVersion.PublicIdentifier + ".png"));
this.ReleaseNotesBrowser.Opacity = 0;
this.ReleaseNotesBrowser.Navigated += (sender, e) => { (this.ReleaseNotesBrowser.Resources["fadeIn"] as Storyboard).Begin(); };
this.ReleaseNotesBrowser.NavigateToString(WebBrowserHelper.WrapContent(NewestVersion.Notes));
this.ReleaseNotesBrowser.Navigating += (sender, e) =>
{
e.Cancel = true;
WebBrowserTask browserTask = new WebBrowserTask();
browserTask.Uri = e.Uri;
browserTask.Show();
};
this.InstallAETX.Click += (sender, e) =>
{
WebBrowserTask webBrowserTask = new WebBrowserTask();
webBrowserTask.Uri = new Uri(HockeyClient.Current.AsInternal().ApiBaseVersion2 + "apps/" + NewestVersion.PublicIdentifier + ".aetx", UriKind.Absolute);
webBrowserTask.Show();
};
this.InstallOverApi.Click += (sender, e) => {
this.Overlay.Visibility = Visibility.Visible;
updateAction.Invoke(NewestVersion);
};
} //This method improves upon the naive method (stringBuffer) as ENCODING.GetString
//allocates a new character array with every invocation, and this method bypasses
//this by reusing the same char array. Surprisingly in tests, this method held
//no improvement.
static void filestream2(string filePath, Action<string> callback)
{
byte[] buffer = new byte[BUFFER_SIZE];
byte[] charBuffer = new byte[MAX_TOKEN_SIZE];
char[] encoderBuffer = new char[ENCODING.GetMaxCharCount(MAX_TOKEN_SIZE)];
int charIndex = 0;
int bufferSize, encodedChars;
using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
do
{
bufferSize = stream.Read(buffer, 0, BUFFER_SIZE);
for (int i = 0; i < bufferSize; i++)
{
if (scannerNoMatch(buffer[i]))
{
charBuffer[charIndex++] = buffer[i];
}
else
{
encodedChars = ENCODING.GetChars(charBuffer, 0, charIndex, encoderBuffer, 0);
callback(new string(encoderBuffer, 0, encodedChars));
charIndex = 0;
}
}
} while (bufferSize != 0);
}
} //Base method - most simple implementation
static void filestream(string filePath, Action<string> callback)
{
byte[] buffer = new byte[BUFFER_SIZE];
byte[] charBuffer = new byte[MAX_TOKEN_SIZE];
int charIndex = 0;
int bufferSize;
using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
do
{
bufferSize = stream.Read(buffer, 0, BUFFER_SIZE);
for (int i = 0; i < bufferSize; i++)
{
if (scannerNoMatch(buffer[i]))
{
charBuffer[charIndex++] = buffer[i];
}
else
{
callback(ENCODING.GetString(charBuffer, 0, charIndex));
charIndex = 0;
}
}
} while (bufferSize != 0);
}
} public static PushStreamContent Create(string fileName, ITracer tracer, Action<ZipArchive> onZip)
{
var content = new PushStreamContent((outputStream, httpContent, transportContext) =>
{
using (tracer.Step("ZipStreamContent.OnZip"))
{
try
{
using (var zip = new ZipArchive(new StreamWrapper(outputStream), ZipArchiveMode.Create, leaveOpen: false))
{
onZip(zip);
}
}
catch (Exception ex)
{
tracer.TraceError(ex);
throw;
}
}
});
content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
content.Headers.ContentDisposition.FileName = fileName;
return content;
}