public void IsCompatibleTypeInterfaceTest()
{
MockDataTarget dataTarget = new MockDataTarget();
Assert.IsTrue(NuGenArgument.IsCompatibleType(dataTarget, typeof(IMockDataTarget)));
Assert.IsFalse(NuGenArgument.IsCompatibleType(dataTarget, typeof(IDataObject)));
}
private void _pictureBox_DragEnter(Object sender, DragEventArgs e)
{
if (NuGenArgument.GetCompatibleDataObjectType(e.Data, typeof(IDescriptor)) != null)
{
e.Effect = DragDropEffects.Copy;
}
}
/*
* StableSort
*/
private static TextChange[] StableSort(IList <TextChange> changes)
{
var array = new TextChange[changes.Count];
changes.CopyTo(array, 0);
for (var i = 0; i < array.Length - 1; i++)
{
Int32 position = array[i].Position;
var index = i;
for (var j = i + 1; j < array.Length; j++)
{
if (array[j].Position < position)
{
position = array[j].Position;
index = j;
}
}
NuGenArgument.Exchange <TextChange>(ref array[i], ref array[index]);
}
return(array);
}
/*
* Verify
*/
/// <summary>
/// Verifies whether the data entered by the user is valid.
/// </summary>
/// <returns><see langword="true"/> if the entered data is valid; otherwise, <see langword="false"/>.</returns>
public bool Verify()
{
if (!NuGenArgument.IsValidDirectoryName(this.directorySelector.Path))
{
MessageBox.Show(
string.Format(Properties.Resources.Argument_InvalidDirectory, new string(Path.GetInvalidPathChars())),
Properties.Resources.Message_Alert,
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation
);
return(false);
}
if (!NuGenArgument.IsValidFilename(this.filenameTextBox.Text))
{
MessageBox.Show(
string.Format(Properties.Resources.Argument_InvalidFilename, new string(Path.GetInvalidFileNameChars())),
Properties.Resources.Message_Alert,
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation
);
this.filenameTextBox.SelectionStart = 0;
this.filenameTextBox.SelectAll();
return(false);
}
return(true);
}
private void _pictureBox_DragDrop(Object sender, DragEventArgs e)
{
Type descriptorType = NuGenArgument.GetCompatibleDataObjectType(e.Data, typeof(IDescriptor));
IDescriptor descriptor = (IDescriptor)e.Data.GetData(descriptorType);
NodeBase nodeToAdd = descriptor.CreateNode(this);
Point cp = _pictureBox.PointToClient(new Point(e.X, e.Y));
AddNode(nodeToAdd, new Point((Int32)(cp.X / _scale), (Int32)(cp.Y / _scale)));
}
public void IsValidFilenameTest()
{
string validFilename = "filename";
Assert.IsTrue(NuGenArgument.IsValidFileName(validFilename));
string invalidFilename = string.Concat(validFilename, new string(Path.GetInvalidFileNameChars()[0], 1));
Assert.IsFalse(NuGenArgument.IsValidFileName(invalidFilename));
}
public void IsValidDirectoryNameTest()
{
String validDirectory = "directory";
Assert.IsTrue(NuGenArgument.IsValidDirectoryName(validDirectory));
String invalidDirectory = String.Concat(validDirectory, new String(Path.GetInvalidPathChars()[0], 1));
Assert.IsFalse(NuGenArgument.IsValidDirectoryName(invalidDirectory));
}
public void GetCompatibleDataObjectTypeInheritanceTest()
{
Assert.AreEqual(
typeof(Button),
NuGenArgument.GetCompatibleDataObjectType(_dataObject, typeof(Control))
);
Assert.IsNull(
NuGenArgument.GetCompatibleDataObjectType(_dataObject, typeof(TextBox))
);
}
public void GetCompatibleDataObjectTypeInterfaceTest()
{
MockDataTarget mockDataTarget = new MockDataTarget();
Assert.AreEqual(
typeof(MockDataTarget),
NuGenArgument.GetCompatibleDataObjectType(new DataObject(mockDataTarget), typeof(IMockDataTarget))
);
Assert.IsNull(
NuGenArgument.GetCompatibleDataObjectType(_dataObject, typeof(IMockObject))
);
}
/*
* OnDragEnter
*/
/// <summary>
/// Raises the <see cref="E:System.Windows.Forms.Control.DragEnter"></see> event.
/// </summary>
/// <param name="e">A <see cref="T:System.Windows.Forms.DragEventArgs"></see> that contains the event data.</param>
protected override void OnDragEnter(DragEventArgs e)
{
if (NuGenArgument.GetCompatibleDataObjectType(e.Data, typeof(NuGenTaskTreeNodeBase)) != null)
{
e.Effect = DragDropEffects.Move;
}
else
{
e.Effect = DragDropEffects.None;
}
base.OnDragEnter(e);
}
public void IsEvenTest()
{
Int32 zeroValue = 0;
Int32 positiveEvenValue = 10;
Int32 positiveOddValue = 1;
Int32 negativeEvenValue = -10;
Int32 negativeOddValue = -1;
Assert.IsTrue(NuGenArgument.IsEven(zeroValue));
Assert.AreNotEqual(NuGenArgument.IsEven(zeroValue), NuGenArgument.IsOdd(zeroValue));
Assert.IsTrue(NuGenArgument.IsEven(positiveEvenValue));
Assert.AreNotEqual(NuGenArgument.IsEven(positiveEvenValue), NuGenArgument.IsOdd(positiveEvenValue));
Assert.IsTrue(NuGenArgument.IsEven(negativeEvenValue));
Assert.AreNotEqual(NuGenArgument.IsEven(negativeEvenValue), NuGenArgument.IsOdd(negativeEvenValue));
Assert.IsFalse(NuGenArgument.IsEven(positiveOddValue));
Assert.AreNotEqual(NuGenArgument.IsEven(positiveOddValue), NuGenArgument.IsOdd(positiveOddValue));
Assert.IsFalse(NuGenArgument.IsEven(negativeOddValue));
Assert.AreNotEqual(NuGenArgument.IsEven(negativeOddValue), NuGenArgument.IsOdd(negativeOddValue));
}
public void ExchangeTest()
{
Int32 aValue = 5;
Int32 bValue = 6;
Int32 a = aValue;
Int32 b = bValue;
NuGenArgument.Exchange <Int32>(ref a, ref b);
Assert.AreEqual(bValue, a);
Assert.AreEqual(aValue, b);
Button buttonAValue = new Button();
Button buttonBValue = new Button();
Button buttonA = buttonAValue;
Button buttonB = buttonBValue;
NuGenArgument.Exchange <Button>(ref buttonA, ref buttonB);
Assert.AreEqual(buttonBValue, buttonA);
Assert.AreEqual(buttonAValue, buttonB);
}
public void ExchangeTest()
{
int aValue = 5;
int bValue = 6;
int a = aValue;
int b = bValue;
NuGenArgument.Exchange <int>(ref a, ref b);
Assert.AreEqual(bValue, a);
Assert.AreEqual(aValue, b);
Button buttonAValue = new Button();
Button buttonBValue = new Button();
Button buttonA = buttonAValue;
Button buttonB = buttonBValue;
NuGenArgument.Exchange <Button>(ref buttonA, ref buttonB);
Assert.AreEqual(buttonBValue, buttonA);
Assert.AreEqual(buttonAValue, buttonB);
}
public void IsValidDirectoryNameEmptyStringTest()
{
Assert.IsFalse(NuGenArgument.IsValidDirectoryName(null));
Assert.IsFalse(NuGenArgument.IsValidDirectoryName(""));
}
public void IsCompatibleTypeArgumentNullExceptionTestOnCompatibleType()
{
NuGenArgument.IsCompatibleType(new Button(), null);
}
public void IsCompatibleTypeInheritenceTest()
{
Assert.IsTrue(NuGenArgument.IsCompatibleType(new Button(), typeof(Control)));
}
public void IsCompatibleTypeEqualTypeTest()
{
Assert.IsTrue(NuGenArgument.IsCompatibleType(new Button(), typeof(Button)));
Assert.IsFalse(NuGenArgument.IsCompatibleType(new TextBox(), typeof(Button)));
Assert.IsFalse(NuGenArgument.IsCompatibleType(null, typeof(Control)));
}
private void _controlPanel_Export(object sender, EventArgs e)
{
if (!NuGenArgument.IsValidDirectoryName(_pathSelector.SelectedPath))
{
MessageBox.Show(
string.Format(res.Argument_InvalidDirectory, new string(Path.GetInvalidPathChars()))
, res.Message_Alert
, MessageBoxButtons.OK
, MessageBoxIcon.Exclamation
);
return;
}
if (!NuGenArgument.IsValidFileName(_templateTextBox.Text))
{
MessageBox.Show(
string.Format(res.Argument_InvalidFilename, new string(Path.GetInvalidFileNameChars()))
, res.Message_Alert
, MessageBoxButtons.OK
, MessageBoxIcon.Exclamation
);
_templateTextBox.SelectAll();
_templateTextBox.Focus();
return;
}
this.SetExportStep();
Image[] images;
if (_thumbnailContainer.SelectedImages.Count > 0)
{
images = new Image[_thumbnailContainer.SelectedImages.Count];
_thumbnailContainer.SelectedImages.CopyTo(images, 0);
}
else
{
images = new Image[_thumbnailContainer.Images.Count];
_thumbnailContainer.Images.CopyTo(images, 0);
}
this.SetExportParams(
_exportProgressBar
, images
, _typeCombo.ImageType
, _formatCombo.FileFormat
, _numWatermarkCheckBox.Checked
, _watermarkFontBlock.SelectedFont
, NuGenControlPaint.ColorFromArgb(100 - _watermarkOpacitySpin.Value, _watermarkColorBox.SelectedColor)
, _watermarkAlignDropDown.SelectedAlignment
, _pathSelector.SelectedPath
, _templateTextBox.Text
);
MethodInvoker methodInvoker = new MethodInvoker(this.ExportImages);
methodInvoker.BeginInvoke(
new AsyncCallback(
delegate
{
this.BeginInvoke(
new MethodInvoker(
delegate
{
this.SetFinishStep();
}
)
);
}
)
, null
);
}
public void GetCompatibleDataObjectTypeArgumentNullExceptionOnCompatibleType()
{
NuGenArgument.GetCompatibleDataObjectType(_dataObject, null);
}
/*
* AddSelectedNode
*/
/// <summary>
/// </summary>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="selectedNodeToAdd"/> is <see langword="null"/>.
/// </exception>
public void AddSelectedNode(TreeNode selectedNodeToAdd, Keys pressedKeys, MouseButtons pressedMouseButtons)
{
if (selectedNodeToAdd == null)
{
throw new ArgumentNullException("selectedNodeToAdd");
}
if ((pressedMouseButtons & MouseButtons.Right) == MouseButtons.Right)
{
if (!this.SelectedNodes.Contains(selectedNodeToAdd))
{
this.SelectedNodes.Clear();
this.SelectedNodes.Add(selectedNodeToAdd);
}
return;
}
if (pressedKeys == Keys.None)
{
this.SelectedNodes.Clear();
this.SelectedNodes.Add(selectedNodeToAdd);
}
else if ((pressedKeys & Keys.Control) != 0)
{
if (this.SelectedNodes.Count == 0)
{
this.SelectedNodes.Add(selectedNodeToAdd);
}
else
{
if (this.SelectedNodes.Contains(selectedNodeToAdd))
{
this.SelectedNodes.Remove(selectedNodeToAdd);
}
else
{
if (this.SelectedNodes[0].Parent == selectedNodeToAdd.Parent)
{
this.SelectedNodes.Add(selectedNodeToAdd);
}
}
}
}
else if ((pressedKeys & Keys.Shift) != 0)
{
if (this.SelectedNodes.Count == 0)
{
this.SelectedNodes.Add(selectedNodeToAdd);
}
else
{
if (this.SelectedNodes[0].Parent == selectedNodeToAdd.Parent)
{
int firstSelectedNodeIndex = this.SelectedNodes[0].Index;
int lastSelectedNodeIndex = selectedNodeToAdd.Index;
TreeNode currentNode = this.SelectedNodes[0];
this.SelectedNodes.Clear();
if (lastSelectedNodeIndex > firstSelectedNodeIndex)
{
lastSelectedNodeIndex++;
}
else if (lastSelectedNodeIndex < firstSelectedNodeIndex)
{
this.SelectedNodes.Add(currentNode);
currentNode = selectedNodeToAdd;
NuGenArgument.Exchange <int>(ref firstSelectedNodeIndex, ref lastSelectedNodeIndex);
}
for (
int nodeIndex = firstSelectedNodeIndex;
nodeIndex < lastSelectedNodeIndex;
nodeIndex++
)
{
if (currentNode != null)
{
if (!this.SelectedNodes.Contains(currentNode))
{
this.SelectedNodes.Add(currentNode);
}
currentNode = currentNode.NextVisibleNode;
}
}
}
}
}
}
public void IsValidFilenameEmptyStringTest()
{
Assert.IsFalse(NuGenArgument.IsValidFileName(null));
Assert.IsFalse(NuGenArgument.IsValidFileName(""));
}
public void GetCompatibleDataObjectTypeArgumentNullExceptionOnDataObject()
{
NuGenArgument.GetCompatibleDataObjectType(null, typeof(IMockDataTarget));
}