// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
-// Copyright (c) 2005,2006 Novell, Inc. (http://www.novell.com)
+// Copyright (c) 2005, 2006, 2007 Novell, Inc. (http://www.novell.com)
//
// Author:
// Pedro MartÃnez Juliá <pedromj@gmail.com>
// Daniel Nauck (dna(at)mono-project(dot)de)
+// Ivan N. Zlatev <contact@i-nz.net>
#if NET_2_0
-using NUnit.Framework;
using System;
+using System.Data;
using System.Drawing;
-using System.Windows.Forms;
-using System.ComponentModel;
using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+using System.Windows.Forms;
-namespace MonoTests.System.Windows.Forms {
+using NUnit.Framework;
+namespace MonoTests.System.Windows.Forms
+{
[TestFixture]
- public class DataGridViewTest {
-
+ public class DataGridViewTest : TestHelper
+ {
private DataGridView grid = null;
[SetUp]
- public void GetReady()
+ protected override void SetUp()
{
grid = new DataGridView();
+ base.SetUp ();
}
[TearDown]
- public void Clean()
+ protected override void TearDown ()
{
grid.Dispose ();
+ base.TearDown ();
}
[Test]
- public void TestDefaultValues () {
+ [ExpectedException (typeof (InvalidOperationException), ExpectedMessage = "Generating Clipboard content is not supported when the ClipboardCopyMode property is Disable.")]
+ public void GetClipboardContentsDisabled ()
+ {
+ using (DataGridView dgv = new DataGridView ()) {
+ dgv.ClipboardCopyMode = DataGridViewClipboardCopyMode.Disable;
+ object o = dgv.GetClipboardContent ();
+ }
+ }
+
+ private class ExposeProtectedProperties : DataGridView
+ {
+ public new Padding DefaultPadding { get { return base.DefaultPadding; } }
+ public new Size DefaultSize { get { return base.DefaultSize; } }
+ public new bool IsDoubleBuffered { get { return base.DoubleBuffered; } }
+
+ public ControlStyles GetControlStyles ()
+ {
+ ControlStyles retval = (ControlStyles)0;
+
+ foreach (ControlStyles cs in Enum.GetValues (typeof (ControlStyles)))
+ if (this.GetStyle (cs) == true)
+ retval |= cs;
+
+ return retval;
+ }
+
+ public bool PublicIsInputKey (Keys keyData)
+ {
+ return base.IsInputKey (keyData);
+ }
+
+ public bool PublicIsInputChar (char charCode)
+ {
+ return base.IsInputChar (charCode);
+ }
+ }
+
+#region GenerateClipboardTest
+ public static void GenerateClipboardTest ()
+ {
+ GenerateClipboardTest (false);
+ GenerateClipboardTest (true);
+ }
+
+ public static string GenerateClipboardTest (bool headers)
+ {
+ StringBuilder result = new StringBuilder ();
+
+ int tab = 0;
+ string classname = headers ? "DataGridViewClipboardHeaderTest" : "DataGridViewClipboardTest";
+
+ append (result, tab, "//");
+ append (result, tab, "// Copyright (c) 2007 Novell, Inc. (http://www.novell.com)");
+ append (result, tab, "//");
+ append (result, tab, "// Author:");
+ append (result, tab, "// DataGridViewTest.GenerateClipboardTest ({0});", headers.ToString ().ToLower ());
+ append (result, tab, "//");
+ append (result, tab, "#if NET_2_0");
+ append (result, tab, "using NUnit.Framework;");
+ append (result, tab, "using System;");
+ append (result, tab, "using System.Drawing;");
+ append (result, tab, "using System.Windows.Forms;");
+ append (result, tab, "using System.ComponentModel;");
+ append (result, tab, "using System.Collections;");
+ append (result, tab, "using System.Text;");
+ append (result, tab, "using System.Collections.Generic;");
+ append (result, tab, "using System.Diagnostics;");
+ append (result, tab, "using System.IO;");
+ append (result, tab, "namespace MonoTests.System.Windows.Forms {"); tab++;
+ append (result, tab, "[TestFixture]");
+ append (result, tab, "public class {0} {{", classname); tab++;
+ append (result, tab, "[Test]");
+ append (result, tab, "public void Test () {"); tab++;
+
+
+ append (result, tab, "DataObject data;");
+ append (result, tab, "DataGridViewRowHeaderTest.DataGridViewRowHeaderClipboardCell row_header_cell;");
+ append (result, tab, "DataGridViewColumnHeaderTest.DataGridViewColumnHeaderClipboardCell col_header_cell;");
+ //append (result, tab, "string csv = null, html = null, utext = null, text = null;");
+ append (result, tab, "string code = null;");
+
+ int counter;
+
+ List<List<int>> selected_bands = new List<List<int>> ();
+ List<List<CellSelection>> selected_cells = new List<List<CellSelection>> ();
+
+ selected_bands.Add (new List<int> ());
+ selected_bands.Add (new List<int> (new int [] { 0 }));
+ selected_bands.Add (new List<int> (new int [] { 2 }));
+ selected_bands.Add (new List<int> (new int [] { 1, 2 }));
+ selected_bands.Add (new List<int> (new int [] { 1, 3 }));
+
+ selected_cells.Add (new List<CellSelection> ());
+ selected_cells.Add (new List<CellSelection> (new CellSelection [] { new CellSelection (0, 0, true) }));
+ selected_cells.Add (new List<CellSelection> (new CellSelection [] { new CellSelection (2, 2, false) }));
+ selected_cells.Add (new List<CellSelection> (new CellSelection [] { new CellSelection (0, 0, false), new CellSelection (2, 2, true) }));
+
+ foreach (DataGridViewClipboardCopyMode copymode in Enum.GetValues (typeof (DataGridViewClipboardCopyMode))) {
+ if (copymode == DataGridViewClipboardCopyMode.Disable)
+ continue;
+
+ counter = 0;
+ foreach (DataGridViewSelectionMode selectionmode in Enum.GetValues (typeof (DataGridViewSelectionMode))) {
+ bool is_row_selectable, is_col_selectable, is_cell_selectable;
+
+ is_row_selectable = selectionmode == DataGridViewSelectionMode.RowHeaderSelect || selectionmode == DataGridViewSelectionMode.FullRowSelect;
+ is_col_selectable = selectionmode == DataGridViewSelectionMode.ColumnHeaderSelect || selectionmode == DataGridViewSelectionMode.FullColumnSelect;
+ is_cell_selectable = selectionmode == DataGridViewSelectionMode.CellSelect || selectionmode == DataGridViewSelectionMode.ColumnHeaderSelect || selectionmode == DataGridViewSelectionMode.RowHeaderSelect;
+
+ foreach (List<int> cols in selected_bands) {
+ if (!is_col_selectable && cols.Count > 0)
+ continue;
+
+ foreach (List<int> rows in selected_bands) {
+ if (!is_row_selectable && rows.Count > 0)
+ continue;
+
+ foreach (List<CellSelection> cells in selected_cells) {
+ if (!is_cell_selectable && cells.Count > 0)
+ continue;
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillForClipboard ()) {
+
+ dgv.SelectionMode = selectionmode;
+ dgv.ClipboardCopyMode = copymode;
+ bool any_selected = false;
+ if (is_col_selectable && cols.Count > 0) {
+ foreach (int c in cols) {
+ dgv.Columns [c].Selected = true;
+ any_selected = true;
+ }
+ }
+ if (is_row_selectable && rows.Count > 0) {
+ foreach (int r in rows) {
+ dgv.Rows [r].Selected = true;
+ any_selected = true;
+ }
+ }
+ if (is_cell_selectable && cells.Count > 0) {
+ foreach (CellSelection selection in cells) {
+ DataGridViewCell cell = dgv.Rows [selection.Row].Cells [selection.Col];
+ if (cell.Selected != selection.Selected) {
+ cell.Selected = selection.Selected;
+ any_selected = true;
+ }
+ }
+ }
+
+ if (any_selected == false && !(cols.Count == 0 && rows.Count == 0 && cells.Count == 0)) {
+ continue;
+ }
+
+ generate_case (result, dgv, copymode.ToString () + "#" + (counter++).ToString (), headers);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ append (result, --tab, "}");
+ append (result, --tab, "}");
+ append (result, --tab, "}");
+ append (result, tab, "#endif"); ;
+
+ throw new NotImplementedException ("Where am I?");
+ // Uncomment the following line, change the path, and comment out the exception.
+ //File.WriteAllText (@"Z:\mono\head\mcs\class\SWF\Test\System.Windows.Forms\" + classname + ".cs", result.ToString ());
+
+ return string.Empty;
+ }
+
+ private static string tabs (int t) { return new string ('\t', t); }
+ private static void append (StringBuilder result, int tab, string text) { result.Append (tabs (tab) + text + "\n"); }
+ private static void append (StringBuilder result, int tab, string text, params object [] args) { result.Append (tabs (tab) + string.Format (text, args) + "\n"); }
+ private static string cs_encode (string literal, string newline) {
+ bool has_newlines = literal.Contains ("\r\n");
+ bool format_string = has_newlines;
+
+ literal = literal.Replace ("\\", "\\\\");
+ literal = literal.Replace ("\"", "\\\"");
+ literal = literal.Replace ("\t", "\\t");
+
+ if (has_newlines) {
+ if (newline == @"""\r\n""") {
+ literal = literal.Replace ("\r\n", @"\r\n");
+ format_string = false;
+ } else {
+ literal = literal.Replace ("\r\n", "{0}");
+ }
+ }
+
+ literal = "\"" + literal + "\"";
+
+ if (format_string) {
+ return "string.Format (" + literal/*.Replace ("{", "{{").Replace ("}", "}}")*/ + ", " + newline + ")";
+ } else {
+ return literal;
+ }
+ }
+
+ private static string cs_encode (string literal) {
+ return cs_encode (literal, "Environment.NewLine");
+ }
+
+ private class CellSelection {
+ public bool Selected;
+ public int Row;
+ public int Col;
+ public CellSelection (int Row, int Col, bool Selected) {
+ this.Selected = Selected;
+ this.Row = Row;
+ this.Col = Col;
+ }
+ }
+
+ static private void generate_case (StringBuilder result, DataGridView dgv, string message, bool headers)
+ {
+ Console.WriteLine (message + ", current length: " + result.Length.ToString ());
+ Debug.WriteLine (message + ", current length: " + result.Length.ToString ());
+
+ if (headers) {
+ if (dgv.SelectionMode != DataGridViewSelectionMode.CellSelect)
+ return;
+ if (dgv.ClipboardCopyMode != DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText)
+ return;
+ }
+
+ int tab = 3;
+ DataObject data;
+ string csv = null, html = null, utext = null, text = null;
+ string code = null;
+ DataGridViewRowHeaderTest.DataGridViewRowHeaderClipboardCell row_header_cell;
+ DataGridViewColumnHeaderTest.DataGridViewColumnHeaderClipboardCell col_header_cell;
+ int counter = 0;
+
+ append (result, tab, "using (DataGridView dgv = DataGridViewCommon.CreateAndFillForClipboard ()) {");
+ tab++;
+
+ append (result, tab, "dgv.SelectionMode = DataGridViewSelectionMode.{0};", dgv.SelectionMode.ToString ());
+ append (result, tab, "dgv.ClipboardCopyMode = DataGridViewClipboardCopyMode.{0};", dgv.ClipboardCopyMode.ToString ());
+
+ switch (dgv.SelectionMode) {
+ case DataGridViewSelectionMode.FullRowSelect:
+ foreach (DataGridViewRow row in dgv.Rows) {
+ if (row.Selected) {
+ append (result, tab, "dgv.Rows [{0}].Selected = true;", row.Index);
+ }
+ }
+ break;
+ case DataGridViewSelectionMode.FullColumnSelect:
+ foreach (DataGridViewColumn col in dgv.Columns) {
+ if (col.Selected) {
+ append (result, tab, "dgv.Columns [{0}].Selected = true;", col.Index);
+ }
+ }
+ break;
+ case DataGridViewSelectionMode.ColumnHeaderSelect:
+ case DataGridViewSelectionMode.RowHeaderSelect:
+ case DataGridViewSelectionMode.CellSelect:
+ if (dgv.SelectionMode == DataGridViewSelectionMode.RowHeaderSelect) {
+ foreach (DataGridViewRow row in dgv.Rows) {
+ if (row.Selected) {
+ append (result, tab, "dgv.Rows [{0}].Selected = true;", row.Index);
+ }
+ }
+ }
+ if (dgv.SelectionMode == DataGridViewSelectionMode.ColumnHeaderSelect) {
+ foreach (DataGridViewColumn col in dgv.Columns) {
+ if (col.Selected) {
+ append (result, tab, "dgv.Columns [{0}].Selected = true;", col.Index);
+ }
+ }
+ }
+ for (int r = 0; r < dgv.RowCount; r++) {
+ for (int c = 0; c < dgv.ColumnCount; c++) {
+ bool rowS = dgv.Rows [r].Selected;
+ bool colS = dgv.Columns [c].Selected;
+ bool cellS = dgv.Rows [r].Cells [c].Selected;
+
+ if ((rowS || colS) && !cellS) {
+ append (result, tab, "dgv.Rows [{0}].Cells [{1}].Selected = false;", r, c);
+ } else if ((!rowS && !colS) && cellS) {
+ append (result, tab, "dgv.Rows [{0}].Cells [{1}].Selected = true;", r, c);
+ }
+ }
+ }
+ break;
+ }
+
+ if (!headers) {
+ data = dgv.GetClipboardContent ();
+ append (result, tab, "data = dgv.GetClipboardContent ();");
+
+ if (data == null) {
+ append (result, tab, "Assert.IsNull (data, {0});", cs_encode ("#" + message + "-" + (counter++).ToString ()));
+ } else {
+ append (result, tab, "Assert.IsNotNull (data, {0});", cs_encode ("#" + message + "-" + (counter++).ToString ()));
+
+ csv = data.GetData (DataFormats.CommaSeparatedValue) as string;
+ html = data.GetData (DataFormats.Html) as string;
+ utext = data.GetData (DataFormats.UnicodeText) as string;
+ text = data.GetData (DataFormats.Text) as string;
+
+ append (result, tab, "Assert.AreEqual ({0}, data.GetData (DataFormats.CommaSeparatedValue), {1});", cs_encode (csv), cs_encode ("#" + message + "-" + (counter++).ToString ()));
+ append (result, tab, "Assert.AreEqual ({0}, data.GetData (DataFormats.Html), {1});", cs_encode (html, @"""\r\n"""), cs_encode ("#" + message + "-" + (counter++).ToString ()));
+ append (result, tab, "Assert.AreEqual ({0}, data.GetData (DataFormats.UnicodeText), {1});", cs_encode (utext), cs_encode ("#" + message + "-" + (counter++).ToString ()));
+ append (result, tab, "Assert.AreEqual ({0}, data.GetData (DataFormats.Text), {1});", cs_encode (text), cs_encode ("#" + message + "-" + (counter++).ToString ()));
+ }
+ } else {
+ bool [] bools = new bool [] { true, false };
+ string [] formats = new string [] { DataFormats.Text, DataFormats.UnicodeText, DataFormats.Html, DataFormats.CommaSeparatedValue };
+
+
+ foreach (bool a in bools) {
+ foreach (bool b in bools) {
+ foreach (bool c in bools) {
+ foreach (bool d in bools) {
+ foreach (string format in formats) {
+ bool did_selected = false;
+ bool did_unselected = false;
+ foreach (DataGridViewRow row in dgv.Rows) {
+ int i = row.Index;
+ if (row.Selected) {
+ if (did_selected)
+ continue;
+ did_selected = true;
+ } else {
+ if (did_unselected)
+ continue;
+ did_unselected = true;
+ }
+ row_header_cell = row.HeaderCell as DataGridViewRowHeaderTest.DataGridViewRowHeaderClipboardCell;
+ if (row_header_cell == null) {
+ append (result, tab, "Assert.IsNull (dgv.Rows [{0}].Headercell, {1});", row.Index, cs_encode ("#" + message + "-" + (counter++).ToString ()));
+ } else {
+ append (result, tab, "row_header_cell = dgv.Rows [{0}].HeaderCell as DataGridViewRowHeaderTest.DataGridViewRowHeaderClipboardCell;", row.Index);
+ code = cs_encode (row_header_cell.GetClipboardContentPublic (i, a, b, c, d, format) as string);
+ append (result, tab, "code = row_header_cell.GetClipboardContentPublic ({0}, {1}, {2}, {3}, {4}, \"{5}\") as string;", i, a.ToString ().ToLower (), b.ToString ().ToLower (), c.ToString ().ToLower (), d.ToString ().ToLower (), format);
+ append (result, tab, "Assert.AreEqual ({0}, code, {1});", code, cs_encode ("#" + message + "-" + (counter++).ToString ()));
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ foreach (bool a in bools) {
+ foreach (bool b in bools) {
+ foreach (bool c in bools) {
+ foreach (bool d in bools) {
+ foreach (string format in formats) {
+ bool did_selected = false;
+ bool did_unselected = false;
+ foreach (DataGridViewColumn col in dgv.Columns) {
+ int i = -1;
+ if (col.Index > 1)
+ continue;
+ if (col.Selected) {
+ if (did_selected)
+ continue;
+ did_selected = true;
+ } else {
+ if (did_unselected)
+ continue;
+ did_unselected = true;
+ }
+ col_header_cell = col.HeaderCell as DataGridViewColumnHeaderTest.DataGridViewColumnHeaderClipboardCell;
+ append (result, tab, "col_header_cell = dgv.Columns [{0}].HeaderCell as DataGridViewColumnHeaderTest.DataGridViewColumnHeaderClipboardCell;", col.Index);
+ code = cs_encode (col_header_cell.GetClipboardContentPublic (i, a, b, c, d, format) as string);
+ append (result, tab, "code = col_header_cell.GetClipboardContentPublic ({0}, {1}, {2}, {3}, {4}, \"{5}\") as string;", i, a.ToString ().ToLower (), b.ToString ().ToLower (), c.ToString ().ToLower (), d.ToString ().ToLower (), format);
+ append (result, tab, "Assert.AreEqual ({0}, code, {1});", code, cs_encode ("#" + message + "-" + (counter++).ToString ()));
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ tab--;
+ append (result, tab, "}");
+ }
+#endregion GenerateClipboardTest
+
+ [Test]
+ public void GetClipboardContents ()
+ {
+ DataObject data;
+ string csv, html, utext, text;
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFill ()) {
+ data = dgv.GetClipboardContent ();
+ Assert.IsNull (data, "#01");
+
+ dgv.Rows [0].Cells [0].Selected = true;
+
+ data = dgv.GetClipboardContent ();
+ Assert.IsNotNull (data, "#B1");
+
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (), "#B2");
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (true), "#B3");
+
+ csv = data.GetData (DataFormats.CommaSeparatedValue) as string;
+ html = data.GetData (DataFormats.Html) as string;
+ utext = data.GetData (DataFormats.UnicodeText) as string;
+ text = data.GetData (DataFormats.Text) as string;
+
+ Assert.AreEqual ("Cell A1", csv, "CSV B");
+ Assert.AreEqual ("Cell A1", utext, "UTEXT B");
+ Assert.AreEqual ("Cell A1", text, "TEXT B");
+ Assert.AreEqual (string.Format(@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000211{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000175{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><TR><TD>Cell A1</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n"), html, "HTML B");
+
+ dgv.Rows [1].Cells [1].Selected = true;
+
+ data = dgv.GetClipboardContent ();
+ Assert.IsNotNull (data, "#C1");
+
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (), "#C2");
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (true), "#C3");
+
+ csv = data.GetData (DataFormats.CommaSeparatedValue) as string;
+ html = data.GetData (DataFormats.Html) as string;
+ utext = data.GetData (DataFormats.UnicodeText) as string;
+ text = data.GetData (DataFormats.Text) as string;
+
+ Assert.AreEqual (string.Format("Cell A1,{0},Cell B2", Environment.NewLine), csv, "CSV C");
+ Assert.AreEqual (string.Format("Cell A1\t{0}\tCell B2", Environment.NewLine), utext, "UTEXT C");
+ Assert.AreEqual (string.Format("Cell A1\t{0}\tCell B2", Environment.NewLine), text, "TEXT C");
+ string tmp;
+ tmp = string.Format(@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000266{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000230{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><TR><TD>Cell A1</TD><TD> </TD></TR><TR><TD> </TD><TD>Cell B2</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n");
+
+ Assert.AreEqual (string.Format(@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000266{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000230{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><TR><TD>Cell A1</TD><TD> </TD></TR><TR><TD> </TD><TD>Cell B2</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n"), html, "HTML C");
+ }
+ }
+
+ [Test]
+ public void GetClipboardContents_HeadersAlways ()
+ {
+ DataObject data;
+ string csv, html, utext, text;
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFill ()) {
+ dgv.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;
+ data = dgv.GetClipboardContent ();
+ Assert.IsNull (data, "#01");
+
+ dgv.Rows [0].Cells [0].Selected = true;
+
+ data = dgv.GetClipboardContent ();
+ Assert.IsNotNull (data, "#B1");
+
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (), "#B2");
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (true), "#B3");
+
+ csv = data.GetData (DataFormats.CommaSeparatedValue) as string;
+ html = data.GetData (DataFormats.Html) as string;
+ utext = data.GetData (DataFormats.UnicodeText) as string;
+ text = data.GetData (DataFormats.Text) as string;
+
+ Assert.AreEqual (string.Format (",A{0},Cell A1", Environment.NewLine), csv, "CSV B");
+ Assert.AreEqual (string.Format ("\tA{0}\tCell A1", Environment.NewLine), utext, "UTEXT B");
+ Assert.AreEqual (string.Format ("\tA{0}\tCell A1", Environment.NewLine), text, "TEXT B");
+ Assert.AreEqual (string.Format (@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000281{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000245{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><THEAD><TH> </TH><TH>A</TH></THEAD><TR><TD ALIGN=\"center\"> </TD><TD>Cell A1</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n"), html, "HTML B");
+
+ dgv.Rows [1].Cells [1].Selected = true;
+
+ data = dgv.GetClipboardContent ();
+ Assert.IsNotNull (data, "#C1");
+
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (), "#C2");
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (true), "#C3");
+
+ csv = data.GetData (DataFormats.CommaSeparatedValue) as string;
+ html = data.GetData (DataFormats.Html) as string;
+ utext = data.GetData (DataFormats.UnicodeText) as string;
+ text = data.GetData (DataFormats.Text) as string;
+
+ Assert.AreEqual (string.Format (",A,B{0},Cell A1,{0},,Cell B2", Environment.NewLine), csv, "CSV C");
+ Assert.AreEqual (string.Format ("\tA\tB{0}\tCell A1\t{0}\t\tCell B2", Environment.NewLine), utext, "UTEXT C");
+ Assert.AreEqual (string.Format ("\tA\tB{0}\tCell A1\t{0}\t\tCell B2", Environment.NewLine), text, "TEXT C");
+ string tmp;
+ tmp = string.Format (@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000266{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000230{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><TR><TD>Cell A1</TD><TD> </TD></TR><TR><TD> </TD><TD>Cell B2</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n");
+
+ Assert.AreEqual (string.Format (@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000376{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000340{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><THEAD><TH> </TH><TH>A</TH><TH>B</TH></THEAD><TR><TD ALIGN=\"center\"> </TD><TD>Cell A1</TD><TD> </TD></TR><TR><TD ALIGN=\"center\"> </TD><TD> </TD><TD>Cell B2</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n"), html, "HTML C");
+ }
+ }
+
+ [Test]
+ public void GetClipboardContents_HeadersNever ()
+ {
+ DataObject data;
+ string csv, html, utext, text;
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFill ()) {
+ dgv.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableWithoutHeaderText;
+ data = dgv.GetClipboardContent ();
+ Assert.IsNull (data, "#01");
+
+ dgv.Rows [0].Cells [0].Selected = true;
+
+ data = dgv.GetClipboardContent ();
+ Assert.IsNotNull (data, "#B1");
+
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (), "#B2");
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (true), "#B3");
+
+ csv = data.GetData (DataFormats.CommaSeparatedValue) as string;
+ html = data.GetData (DataFormats.Html) as string;
+ utext = data.GetData (DataFormats.UnicodeText) as string;
+ text = data.GetData (DataFormats.Text) as string;
+
+ Assert.AreEqual ("Cell A1", csv, "CSV B");
+ Assert.AreEqual ("Cell A1", utext, "UTEXT B");
+ Assert.AreEqual ("Cell A1", text, "TEXT B");
+ Assert.AreEqual (string.Format (@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000211{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000175{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><TR><TD>Cell A1</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n"), html, "HTML B");
+
+ dgv.Rows [1].Cells [1].Selected = true;
+
+ data = dgv.GetClipboardContent ();
+ Assert.IsNotNull (data, "#C1");
+
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (), "#C2");
+ Assert.AreEqual (new string [] { DataFormats.CommaSeparatedValue, DataFormats.Html, DataFormats.UnicodeText, DataFormats.Text }, data.GetFormats (true), "#C3");
+
+ csv = data.GetData (DataFormats.CommaSeparatedValue) as string;
+ html = data.GetData (DataFormats.Html) as string;
+ utext = data.GetData (DataFormats.UnicodeText) as string;
+ text = data.GetData (DataFormats.Text) as string;
+
+ Assert.AreEqual (string.Format ("Cell A1,{0},Cell B2", Environment.NewLine), csv, "CSV C");
+ Assert.AreEqual (string.Format ("Cell A1\t{0}\tCell B2", Environment.NewLine), utext, "UTEXT C");
+ Assert.AreEqual (string.Format ("Cell A1\t{0}\tCell B2", Environment.NewLine), text, "TEXT C");
+ string tmp;
+ tmp = string.Format (@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000266{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000230{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><TR><TD>Cell A1</TD><TD> </TD></TR><TR><TD> </TD><TD>Cell B2</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n");
+
+ Assert.AreEqual (string.Format (@"Version:1.0{0}" +
+"StartHTML:00000097{0}" +
+"EndHTML:00000266{0}" +
+"StartFragment:00000133{0}" +
+"EndFragment:00000230{0}" +
+"<HTML>{0}" +
+"<BODY>{0}" +
+"<!--StartFragment--><TABLE><TR><TD>Cell A1</TD><TD> </TD></TR><TR><TD> </TD><TD>Cell B2</TD></TR></TABLE>{0}" +
+"<!--EndFragment-->{0}" +
+"</BODY>{0}" +
+"</HTML>", "\r\n"), html, "HTML C");
+ }
+ }
+
+ [Test]
+ public void EditingRow ()
+ {
+ using (DataGridView dgv = new DataGridView ()) {
+ Assert.AreEqual (true, dgv.AllowUserToAddRows, "1");
+ Assert.AreEqual (0, dgv.RowCount, "2");
+ Assert.AreEqual (-1, dgv.NewRowIndex, "3");
+ dgv.Columns.Add ("A", "B");
+ Assert.AreEqual (1, dgv.RowCount, "4");
+
+ int added;
+ added = dgv.Rows.Add ("a");
+ Assert.AreEqual (0, added, "5");
+ }
+ }
+
+ [Test] // bug 82226
+ public void EditingRowAfterAddingColumns ()
+ {
+ using (DataGridView _dataGridView = new DataGridView ()) {
+ DataGridViewTextBoxColumn _nameTextBoxColumn;
+ DataGridViewTextBoxColumn _firstNameTextBoxColumn;
+ //
+ // _nameTextBoxColumn
+ //
+ _nameTextBoxColumn = new DataGridViewTextBoxColumn ();
+ _nameTextBoxColumn.HeaderText = "Name";
+ _dataGridView.Columns.Add (_nameTextBoxColumn);
+ //
+ // _firstNameTextBoxColumn
+ //
+ _firstNameTextBoxColumn = new DataGridViewTextBoxColumn ();
+ _firstNameTextBoxColumn.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
+ _firstNameTextBoxColumn.HeaderText = "First Name";
+ _dataGridView.Columns.Add (_firstNameTextBoxColumn);
+
+ _dataGridView.Rows.Add ("de Icaza", "Miguel");
+ _dataGridView.Rows.Add ("Toshok", "Chris");
+ _dataGridView.Rows.Add ("Harper", "Jackson");
+
+ Assert.AreEqual (4, _dataGridView.RowCount, "#01");
+ Assert.AreEqual (2, _dataGridView.Rows [3].Cells.Count, "#02");
+ }
+ }
+
+ [Test]
+ public void bug_81918 ()
+ {
+ using (DataGridView dgv = new DataGridView ()) {
+ DataGridViewColumn col = new DataGridViewComboBoxColumn ();
+
+ dgv.Columns.Add (col);
+
+ dgv.Rows.Add ("a");
+
+ DataGridViewComboBoxCell cell = (DataGridViewComboBoxCell) dgv [0, 0];
+ }
+ }
+
+ [Test]
+ public void SelectedRowsTest ()
+ {
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ dgv.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
+ dgv.Rows [1].Selected = true;
+ Assert.AreEqual (1, dgv.SelectedRows.Count, "1-1");
+ Assert.AreEqual (1, dgv.SelectedRows [0].Index, "1-2");
+ dgv.Rows [3].Selected = true;
+ Assert.AreEqual (2, dgv.SelectedRows.Count, "1-3");
+ Assert.AreEqual (3, dgv.SelectedRows [0].Index, "1-4");
+ Assert.AreEqual (1, dgv.SelectedRows [1].Index, "1-5");
+ dgv.Rows [2].Selected = true;
+ Assert.AreEqual (3, dgv.SelectedRows.Count, "1-6");
+ Assert.AreEqual (2, dgv.SelectedRows [0].Index, "1-7");
+ Assert.AreEqual (3, dgv.SelectedRows [1].Index, "1-8");
+ Assert.AreEqual (1, dgv.SelectedRows [2].Index, "1-9");
+ }
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ dgv.SelectionMode = DataGridViewSelectionMode.CellSelect;
+ dgv.Rows [1].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "3-1");
+ dgv.Rows [3].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "3-3");
+ dgv.Rows [2].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "3-6");
+ }
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ foreach (DataGridViewColumn col in dgv.Columns)
+ col.SortMode = DataGridViewColumnSortMode.NotSortable;
+ dgv.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
+ dgv.Rows [1].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "4-1");
+ dgv.Rows [3].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "4-3");
+ dgv.Rows [2].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "4-6");
+ }
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ foreach (DataGridViewColumn col in dgv.Columns)
+ col.SortMode = DataGridViewColumnSortMode.NotSortable;
+ dgv.SelectionMode = DataGridViewSelectionMode.FullColumnSelect;
+ dgv.Rows [1].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "5-1");
+ dgv.Rows [3].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "5-3");
+ dgv.Rows [2].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedRows.Count, "5-6");
+ }
+ }
+
+ [Test] // bug #325979
+ public void SelectedRows_FindColumnByName ()
+ {
+ DataTable dt = new DataTable ();
+ dt.Columns.Add ("Date", typeof (DateTime));
+ dt.Columns.Add ("Registered", typeof (bool));
+ dt.Columns.Add ("Event", typeof (string));
+
+ DataRow row = dt.NewRow ();
+ row ["Date"] = new DateTime (2007, 2, 3);
+ row ["Event"] = "one";
+ row ["Registered"] = false;
+ dt.Rows.Add (row);
+
+ row = dt.NewRow ();
+ row ["Date"] = new DateTime (2008, 3, 4);
+ row ["Event"] = "two";
+ row ["Registered"] = true;
+ dt.Rows.Add (row);
+
+ DataGridView dgv = new DataGridView ();
+ dgv.DataSource = dt;
+
+ Form form = new Form ();
+ form.ShowInTaskbar = false;
+ form.Controls.Add (dgv);
+ form.Show ();
+
+ dgv.Rows [1].Selected = true;
+
+ DataGridViewCell cell = dgv.SelectedRows [0].Cells ["DaTE"];
+ Assert.IsNotNull (cell, "#A1");
+ Assert.IsNotNull (cell.OwningColumn, "#A2");
+ Assert.AreEqual ("Date", cell.OwningColumn.Name, "#A3");
+ Assert.IsNotNull (cell.Value, "#A4");
+ Assert.AreEqual (new DateTime (2008, 3, 4), cell.Value, "#A5");
+
+ cell = dgv.SelectedRows [0].Cells ["Event"];
+ Assert.IsNotNull (cell, "#B1");
+ Assert.IsNotNull (cell.OwningColumn, "#B2");
+ Assert.AreEqual ("Event", cell.OwningColumn.Name, "#B3");
+ Assert.IsNotNull (cell.Value, "#B3");
+ Assert.AreEqual ("two", cell.Value, "#B4");
+
+ form.Dispose ();
+ }
+
+ [Test]
+ public void SelectedColumnsTest ()
+ {
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ foreach (DataGridViewColumn col in dgv.Columns)
+ col.SortMode = DataGridViewColumnSortMode.NotSortable;
+ dgv.SelectionMode = DataGridViewSelectionMode.FullColumnSelect;
+ dgv.Columns [1].Selected = true;
+ Assert.AreEqual (1, dgv.SelectedColumns.Count, "1-1");
+ Assert.AreEqual (1, dgv.SelectedColumns [0].Index, "1-2");
+ dgv.Columns [3].Selected = true;
+ Assert.AreEqual (2, dgv.SelectedColumns.Count, "1-3");
+ Assert.AreEqual (3, dgv.SelectedColumns [0].Index, "1-4");
+ Assert.AreEqual (1, dgv.SelectedColumns [1].Index, "1-5");
+ dgv.Columns [2].Selected = true;
+ Assert.AreEqual (3, dgv.SelectedColumns.Count, "1-6");
+ Assert.AreEqual (2, dgv.SelectedColumns [0].Index, "1-7");
+ Assert.AreEqual (3, dgv.SelectedColumns [1].Index, "1-8");
+ Assert.AreEqual (1, dgv.SelectedColumns [2].Index, "1-9");
+ }
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ foreach (DataGridViewColumn col in dgv.Columns)
+ col.SortMode = DataGridViewColumnSortMode.NotSortable;
+ dgv.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
+ dgv.Columns [1].Selected = true;
+ Assert.AreEqual (1, dgv.SelectedColumns.Count, "2-1");
+ Assert.AreEqual (1, dgv.SelectedColumns [0].Index, "2-2");
+ dgv.Columns [3].Selected = true;
+ Assert.AreEqual (2, dgv.SelectedColumns.Count, "2-3");
+ Assert.AreEqual (3, dgv.SelectedColumns [0].Index, "2-4");
+ Assert.AreEqual (1, dgv.SelectedColumns [1].Index, "2-5");
+ dgv.Columns [2].Selected = true;
+ Assert.AreEqual (3, dgv.SelectedColumns.Count, "2-6");
+ Assert.AreEqual (2, dgv.SelectedColumns [0].Index, "2-7");
+ Assert.AreEqual (3, dgv.SelectedColumns [1].Index, "2-8");
+ Assert.AreEqual (1, dgv.SelectedColumns [2].Index, "2-9");
+ }
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ dgv.SelectionMode = DataGridViewSelectionMode.CellSelect;
+ dgv.Columns [1].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "3-1");
+ dgv.Columns [3].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "3-3");
+ dgv.Columns [2].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "3-6");
+ }
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ foreach (DataGridViewColumn col in dgv.Columns)
+ col.SortMode = DataGridViewColumnSortMode.NotSortable;
+ dgv.SelectionMode = DataGridViewSelectionMode.RowHeaderSelect;
+ dgv.Columns [1].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "4-1");
+ dgv.Columns [3].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "4-3");
+ dgv.Columns [2].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "4-6");
+ }
+
+ using (DataGridView dgv = DataGridViewCommon.CreateAndFillBig ()) {
+ foreach (DataGridViewColumn col in dgv.Columns)
+ col.SortMode = DataGridViewColumnSortMode.NotSortable;
+ dgv.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
+ dgv.Columns [1].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "5-1");
+ dgv.Columns [3].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "5-3");
+ dgv.Columns [2].Selected = true;
+ Assert.AreEqual (0, dgv.SelectedColumns.Count, "5-6");
+ }
+ }
+
+ [Test]
+ public void TopLeftHeaderCellTest ()
+ {
+ Assert.Ignore("Missing quite a few bits still");
+
+ using (DataGridView dgv = new DataGridView ()) {
+ DataGridViewHeaderCell cell = dgv.TopLeftHeaderCell;
+
+ cell = dgv.TopLeftHeaderCell;
+
+ Assert.IsNotNull (cell, "#01");
+ Assert.AreEqual (cell.DataGridView, dgv, "#02");
+ Assert.AreEqual ("DataGridViewTopLeftHeaderCell", cell.GetType ().Name, "#03");
+
+ Assert.IsNotNull (cell.AccessibilityObject, "#cell.AccessibilityObject");
+ Assert.AreEqual (-1, cell.ColumnIndex, "#cell.ColumnIndex");
+ // /* NIE for the moment... */ Assert.IsNotNull (cell.ContentBounds, "#cell.ContentBounds");
+ Assert.IsNull (cell.ContextMenuStrip, "#cell.ContextMenuStrip");
+ Assert.IsNotNull (cell.DataGridView, "#cell.DataGridView");
+ Assert.IsNull (cell.DefaultNewRowValue, "#cell.DefaultNewRowValue");
+ Assert.AreEqual (false, cell.Displayed, "#cell.Displayed");
+ // /* NIE for the moment... */ Assert.AreEqual (@"", cell.EditedFormattedValue, "#cell.EditedFormattedValue");
+ Assert.IsNotNull (cell.EditType, "#cell.EditType");
+ Assert.IsNotNull (cell.ErrorIconBounds, "#cell.ErrorIconBounds");
+ Assert.AreEqual (@"", cell.ErrorText, "#cell.ErrorText");
+ // /* NIE for the moment... */ Assert.AreEqual (@"", cell.FormattedValue, "#cell.FormattedValue");
+ Assert.IsNotNull (cell.FormattedValueType, "#cell.FormattedValueType");
+ // /* NIE for the moment... */ Assert.AreEqual (true, cell.Frozen, "#cell.Frozen");
+ Assert.AreEqual (false, cell.HasStyle, "#cell.HasStyle");
+ Assert.AreEqual (DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.InheritedState, "#cell.InheritedState");
+ Assert.IsNotNull (cell.InheritedStyle, "#cell.InheritedStyle");
+ try {
+ object zxf = cell.IsInEditMode;
+ TestHelper.RemoveWarning (zxf);
+ Assert.Fail ("Expected 'System.InvalidOperationException', but no exception was thrown.", "#cell.IsInEditMode");
+ } catch (InvalidOperationException ex) {
+ Assert.AreEqual (@"Operation cannot be performed on a cell of a shared row.", ex.Message);
+ } catch (Exception ex) {
+ Assert.Fail ("Expected 'System.InvalidOperationException', got '" + ex.GetType ().FullName + "'.", "#cell.IsInEditMode");
+ }
+ Assert.IsNull (cell.OwningColumn, "#cell.OwningColumn");
+ Assert.IsNull (cell.OwningRow, "#cell.OwningRow");
+ Assert.IsNotNull (cell.PreferredSize, "#cell.PreferredSize");
+ Assert.AreEqual (true, cell.ReadOnly, "#cell.ReadOnly");
+ Assert.AreEqual (true, cell.Resizable, "#cell.Resizable");
+ Assert.AreEqual (-1, cell.RowIndex, "#cell.RowIndex");
+ Assert.AreEqual (false, cell.Selected, "#cell.Selected");
+ Assert.IsNotNull (cell.Size, "#cell.Size");
+ Assert.AreEqual (DataGridViewElementStates.None, cell.State, "#cell.State");
+ if (cell.HasStyle)
+ Assert.IsNotNull (cell.Style, "#cell.Style");
+ Assert.IsNull (cell.Tag, "#cell.Tag");
+ Assert.AreEqual (@"", cell.ToolTipText, "#cell.ToolTipText");
+ Assert.IsNull (cell.Value, "#cell.Value");
+ Assert.IsNotNull (cell.ValueType, "#cell.ValueType");
+ Assert.AreEqual (true, cell.Visible, "#cell.Visible");
+ }
+ }
+
+ [Test]
+ public void TestDefaultValues ()
+ {
DataGridView grid = new DataGridView ();
Assert.AreEqual (true, grid.AllowUserToAddRows, "#A1");
Assert.AreEqual (true, grid.AllowUserToDeleteRows, "#A2");
Assert.AreEqual (false, grid.VirtualMode, "#A45");
}
- #region AutoSizeColumnsModeExceptions
+#region AutoSizeColumnsModeExceptions
[Test]
- [ExpectedException(typeof(InvalidEnumArgumentException))]
- public void TestAutoSizeColumnsModeInvalidEnumArgumentException () {
+ [ExpectedException (typeof (InvalidEnumArgumentException))]
+ public void TestAutoSizeColumnsModeInvalidEnumArgumentException ()
+ {
DataGridView grid = new DataGridView();
grid.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill | DataGridViewAutoSizeColumnsMode.None;
}
[Test]
- [ExpectedException(typeof(InvalidOperationException))]
- public void TestAutoSizeColumnsModeInvalidOperationException1 () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void TestAutoSizeColumnsModeInvalidOperationException1 ()
+ {
+ DataGridView grid = new DataGridView ();
grid.ColumnHeadersVisible = false;
- DataGridViewColumn col = new DataGridViewColumn();
+ DataGridViewColumn col = new DataGridViewColumn ();
col.AutoSizeMode = DataGridViewAutoSizeColumnMode.NotSet;
- grid.Columns.Add(col);
+ grid.Columns.Add (col);
grid.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.ColumnHeader;
}
[Test]
- [ExpectedException(typeof(InvalidOperationException))]
- public void TestAutoSizeColumnsModeInvalidOperationException2 () {
- DataGridView grid = new DataGridView();
- DataGridViewColumn col = new DataGridViewColumn();
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void TestAutoSizeColumnsModeInvalidOperationException2 ()
+ {
+ DataGridView grid = new DataGridView ();
+ DataGridViewColumn col = new DataGridViewColumn ();
col.AutoSizeMode = DataGridViewAutoSizeColumnMode.NotSet;
col.Frozen = true;
- grid.Columns.Add(col);
+ grid.Columns.Add (col);
grid.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
}
- #endregion
+#endregion
- #region AutoSizeRowsModeExceptions
+#region AutoSizeRowsModeExceptions
[Test]
- [ExpectedException(typeof(InvalidEnumArgumentException))]
- public void TestAutoSizeRowsModeInvalidEnumArgumentException () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidEnumArgumentException))]
+ public void TestAutoSizeRowsModeInvalidEnumArgumentException ()
+ {
+ DataGridView grid = new DataGridView ();
grid.AutoSizeRowsMode = (DataGridViewAutoSizeRowsMode) 4;
}
[Test]
- [ExpectedException(typeof(InvalidOperationException))]
- public void TestAutoSizeRowsModeInvalidOperationException1 () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void TestAutoSizeRowsModeInvalidOperationException1 ()
+ {
+ DataGridView grid = new DataGridView ();
grid.RowHeadersVisible = false;
grid.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllHeaders;
}
[Test]
- [ExpectedException(typeof(InvalidOperationException))]
- public void TestAutoSizeRowsModeInvalidOperationException2 () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void TestAutoSizeRowsModeInvalidOperationException2 ()
+ {
+ DataGridView grid = new DataGridView ();
grid.RowHeadersVisible = false;
grid.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.DisplayedHeaders;
}
- #endregion
+#endregion
[Test]
- [ExpectedException(typeof(ArgumentException))]
- public void TestBackgroundColorArgumentException () {
- DataGridView grid = new DataGridView();
+ public void AutoResizeColumTest ()
+ {
+ using (Form f = new Form ()) {
+ f.Show ();
+ using (DataGridView dgv = new DataGridView ()) {
+ f.Controls.Add (dgv);
+
+ DataGridViewColumn col, col2, col3;
+
+ Assert.AreEqual ("{Width=240, Height=150}", dgv.ClientSize.ToString (), "#01");
+
+ col = new DataGridViewColumn ();
+ col.MinimumWidth = 20;
+ col.FillWeight = 20;
+ col.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
+ col.CellTemplate = new DataGridViewTextBoxCell ();
+
+ Assert.AreEqual (100, col.Width, "#02");
+ dgv.Columns.Add (col);
+
+ Assert.AreEqual (197, col.Width, "#03");
+
+ col2 = new DataGridViewColumn ();
+ col2.MinimumWidth = 20;
+ col2.FillWeight = 40;
+ col2.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
+ col2.CellTemplate = new DataGridViewTextBoxCell (); ;
+ dgv.Columns.Add (col2);
+
+ Assert.AreEqual (66, col.Width, "#04");
+ Assert.AreEqual (131, col2.Width, "#05");
+
+ col3 = new DataGridViewColumn ();
+ col3.MinimumWidth = 20;
+ col3.FillWeight = 5;
+ col3.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
+ col3.CellTemplate = new DataGridViewTextBoxCell (); ;
+ dgv.Columns.Add (col3);
+
+ Assert.AreEqual (59, col.Width, "#04");
+ Assert.AreEqual (118, col2.Width, "#05");
+ Assert.AreEqual (20, col3.Width, "#05");
+ }
+ }
+ }
+
+ [Test]
+ public void ControlsTest ()
+ {
+ using (DataGridView grid = new DataGridView ()) {
+ Assert.AreEqual ("DataGridViewControlCollection", grid.Controls.GetType ().Name, "#01");
+ Assert.AreEqual (2, grid.Controls.Count, "#02");
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void TestBackgroundColorArgumentException ()
+ {
+ DataGridView grid = new DataGridView ();
grid.BackgroundColor = Color.Empty;
}
[Test]
[ExpectedException(typeof(InvalidEnumArgumentException))]
- public void TestBorderStyleInvalidEnumArgumentException () {
- DataGridView grid = new DataGridView();
+ public void TestBorderStyleInvalidEnumArgumentException ()
+ {
+ DataGridView grid = new DataGridView ();
grid.BorderStyle = BorderStyle.FixedSingle | BorderStyle.Fixed3D;
}
[Test]
- public void ColumnCount () {
- DataGridView grid = new DataGridView();
- Assert.AreEqual (0, grid.ColumnCount, "#A1");
+ public void ColumnCount ()
+ {
+ DataGridView dgv = new DataGridView ();
+
+ dgv.RowCount = 10;
+ dgv.ColumnCount = 2;
+
+ Assert.AreEqual (10, dgv.RowCount, "A1");
+ Assert.AreEqual (2, dgv.ColumnCount, "A2");
+
+ dgv.ColumnCount = 1;
+
+ Assert.AreEqual (10, dgv.RowCount, "B1");
+ Assert.AreEqual (1, dgv.ColumnCount, "B2");
+
+ dgv.ColumnCount = 3;
+
+ Assert.AreEqual (10, dgv.RowCount, "C1");
+ Assert.AreEqual (3, dgv.ColumnCount, "C2");
+
+
+ dgv.ColumnCount = 0;
+
+ Assert.AreEqual (0, dgv.RowCount, "D1");
+ Assert.AreEqual (0, dgv.ColumnCount, "D2");
+
+ Assert.AreEqual (0, dgv.ColumnCount, "E1");
try {
- grid.ColumnCount = -1;
- Assert.Fail ("#B1");
+ dgv.ColumnCount = -1;
+ Assert.Fail ("F1");
} catch (ArgumentOutOfRangeException ex) {
- Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
- Assert.IsNotNull (ex.Message, "#B3");
- Assert.IsNotNull (ex.ParamName, "#B4");
- Assert.AreEqual ("ColumnCount", ex.ParamName, "#B5");
- Assert.IsNull (ex.InnerException, "#B6");
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "F2");
+ Assert.IsNotNull (ex.Message, "F3");
+ Assert.IsNotNull (ex.ParamName, "F4");
+ Assert.AreEqual ("ColumnCount", ex.ParamName, "F5");
+ Assert.IsNull (ex.InnerException, "F6");
}
}
[Test]
- [ExpectedException(typeof(InvalidOperationException))]
- public void TestColumnCountInvalidOperationException () {
- DataGridView grid = new DataGridView();
- grid.DataSource = new ArrayList();
+ public void ColumnCountIncrease ()
+ {
+ DataGridView dgv = new DataGridView ();
+ dgv.ColumnCount = 1;
+
+ // Increasing the ColumnCount adds TextBoxColumns, not generic columns
+ Assert.AreEqual ("System.Windows.Forms.DataGridViewTextBoxColumn", dgv.Columns[0].GetType ().ToString (), "A1");
+ }
+
+
+ [Test]
+ public void ColumnCountDecrease ()
+ {
+ DataGridView dgv = new DataGridView ();
+ dgv.ColumnCount = 6;
+ Assert.AreEqual (6, dgv.ColumnCount, "A1");
+
+ dgv.ColumnCount = 3;
+ Assert.AreEqual (3, dgv.ColumnCount, "A2");
+
+ // Increasing the ColumnCount adds TextBoxColumns, not generic columns
+ Assert.AreEqual ("System.Windows.Forms.DataGridViewTextBoxColumn", dgv.Columns[0].GetType ().ToString (), "A3");
+ Assert.AreEqual ("System.Windows.Forms.DataGridViewTextBoxColumn", dgv.Columns[1].GetType ().ToString (), "A4");
+ Assert.AreEqual ("System.Windows.Forms.DataGridViewTextBoxColumn", dgv.Columns[2].GetType ().ToString (), "A5");
+ }
+
+ private class DataItem
+ {
+ public string Text {
+ get { return String.Empty; }
+ }
+
+ [Browsable (false)]
+ public string NotVisible {
+ get { return String.Empty; }
+ }
+ }
+
+ [Test]
+ public void NoDuplicateAutoGeneratedColumn ()
+ {
+ List<DataItem> dataList = new List<DataItem> ();
+ dataList.Add (new DataItem ());
+ dataList.Add (new DataItem ());
+
+ DataGridViewTextBoxColumn column = new DataGridViewTextBoxColumn ();
+ column.DataPropertyName = "Text";
+ column.HeaderText = "Custom Column";
+ grid.Columns.Add (column);
+
+ grid.DataSource = dataList;
+ // Test that the column autogeneration hasn't generated duplicate column
+ // for the property Text
+ Assert.AreEqual (1, grid.Columns.Count, "#1");
+ Assert.AreEqual ("Custom Column", grid.Columns[0].HeaderText, "#2");
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void TestColumnCountInvalidOperationException ()
+ {
+ DataGridView grid = new DataGridView ();
+ grid.DataSource = new ArrayList ();
grid.ColumnCount = 0;
}
[Test]
- public void ColumnHeadersHeight () {
- DataGridView grid = new DataGridView();
+ public void ColumnHeadersHeight ()
+ {
+ DataGridView grid = new DataGridView ();
Assert.AreEqual (23, grid.ColumnHeadersHeight, "#A1");
grid.ColumnHeadersHeight = 4;
Assert.AreEqual (4, grid.ColumnHeadersHeight, "#A2");
}
[Test]
- [ExpectedException(typeof(InvalidEnumArgumentException))]
- public void TestColumnHeadersHeightSizeModeInvalidEnumArgumentException () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidEnumArgumentException))]
+ public void TestColumnHeadersHeightSizeModeInvalidEnumArgumentException ()
+ {
+ DataGridView grid = new DataGridView ();
grid.ColumnHeadersHeightSizeMode = (DataGridViewColumnHeadersHeightSizeMode) 3;
}
[Test]
- public void RowHeadersWidth () {
+ public void RowHeadersWidth ()
+ {
DataGridView grid = new DataGridView();
Assert.AreEqual (41, grid.RowHeadersWidth, "#A1");
grid.RowHeadersWidth = 4;
}
[Test]
- [ExpectedException(typeof(InvalidEnumArgumentException))]
+ [ExpectedException (typeof (InvalidEnumArgumentException))]
public void TestDataGridViewRowHeadersWidthSizeModeInvalidEnumArgumentException () {
- DataGridView grid = new DataGridView();
+ DataGridView grid = new DataGridView ();
grid.RowHeadersWidthSizeMode = (DataGridViewRowHeadersWidthSizeMode) 5;
}
[Test]
- [ExpectedException(typeof(InvalidEnumArgumentException))]
- public void TestScrollBarsInvalidEnumArgumentException () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidEnumArgumentException))]
+ public void TestScrollBarsInvalidEnumArgumentException ()
+ {
+ DataGridView grid = new DataGridView ();
grid.ScrollBars = (ScrollBars) 4;
}
[Test]
- [ExpectedException(typeof(InvalidEnumArgumentException))]
- public void TestSelectionModeInvalidEnumArgumentException () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidEnumArgumentException))]
+ public void TestSelectionModeInvalidEnumArgumentException ()
+ {
+ DataGridView grid = new DataGridView ();
grid.SelectionMode = (DataGridViewSelectionMode) 5;
}
[Test]
- [ExpectedException(typeof(InvalidEnumArgumentException))]
- public void TestAutoResizeRowsInvalidEnumArgumentException () {
- DataGridView grid = new DataGridView();
- grid.AutoResizeRows((DataGridViewAutoSizeRowsMode) 4);
+ [ExpectedException (typeof (InvalidEnumArgumentException))]
+ public void TestAutoResizeRowsInvalidEnumArgumentException ()
+ {
+ DataGridView grid = new DataGridView ();
+ grid.AutoResizeRows ((DataGridViewAutoSizeRowsMode) 4);
}
[Test]
- [ExpectedException(typeof(InvalidOperationException))]
- public void TestAutoResizeRowsInvalidOperationException1 () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void TestAutoResizeRowsInvalidOperationException1 ()
+ {
+ DataGridView grid = new DataGridView ();
grid.RowHeadersVisible = false;
- grid.AutoResizeRows(DataGridViewAutoSizeRowsMode.AllHeaders);
+ grid.AutoResizeRows (DataGridViewAutoSizeRowsMode.AllHeaders);
}
[Test]
- [ExpectedException(typeof(InvalidOperationException))]
- public void TestAutoResizeRowsInvalidOperationException2 () {
- DataGridView grid = new DataGridView();
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void TestAutoResizeRowsInvalidOperationException2 ()
+ {
+ DataGridView grid = new DataGridView ();
grid.RowHeadersVisible = false;
- grid.AutoResizeRows(DataGridViewAutoSizeRowsMode.DisplayedHeaders);
+ grid.AutoResizeRows (DataGridViewAutoSizeRowsMode.DisplayedHeaders);
}
[Test]
- [ExpectedException(typeof(ArgumentException))]
- public void TestAutoResizeRowsArgumentException () {
- DataGridView grid = new DataGridView();
- grid.AutoResizeRows(DataGridViewAutoSizeRowsMode.None);
+ [ExpectedException (typeof (ArgumentException))]
+ public void TestAutoResizeRowsArgumentException ()
+ {
+ DataGridView grid = new DataGridView ();
+ grid.AutoResizeRows (DataGridViewAutoSizeRowsMode.None);
}
[Test]
Assert.AreEqual (DataGridViewTriState.False, grid.DefaultCellStyle.WrapMode, "#A7");
}
+ [Test]
+ public void MethodIsInputKey ()
+ {
+ string result = string.Empty;
+ string expected = "13;13;33;33;34;34;35;36;37;38;39;40;46;48;96;113;";
+
+ ExposeProtectedProperties dgv = new ExposeProtectedProperties ();
+
+ foreach (Keys k in Enum.GetValues (typeof (Keys)))
+ if (dgv.PublicIsInputKey (k))
+ result += ((int)k).ToString () + ";";
+
+ Assert.AreEqual (expected, result, "A1");
+ }
+
+ [Test]
+ public void MethodIsInputChar ()
+ {
+ bool result = false;
+
+ ExposeProtectedProperties dgv = new ExposeProtectedProperties ();
+
+ for (int i = 0; i < 255; i++)
+ if (!dgv.PublicIsInputChar ((char)i))
+ result = true;
+
+ // Basically, it always returns true
+ Assert.AreEqual (false, result, "A1");
+ }
+
[Test]
public void RowsDefaultCellStyle ()
{
get { return base.DefaultSize; }
}
}
+
+ [Test]
+ public void bug_82326 ()
+ {
+ using (Form f = new Form ()) {
+ DataGridView _dataGrid;
+ DataGridViewTextBoxColumn _column;
+
+ _dataGrid = new DataGridView ();
+ _column = new DataGridViewTextBoxColumn ();
+ f.SuspendLayout ();
+ ((ISupportInitialize)(_dataGrid)).BeginInit ();
+ //
+ // _dataGrid
+ //
+ _dataGrid.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize;
+ _dataGrid.Columns.Add (_column);
+ _dataGrid.RowTemplate.Height = 21;
+ _dataGrid.Location = new Point (12, 115);
+ _dataGrid.Size = new Size (268, 146);
+ _dataGrid.TabIndex = 0;
+ //
+ // _column
+ //
+ _column.HeaderText = "Column";
+ //
+ // MainForm
+ //
+ f.ClientSize = new Size (292, 273);
+ f.Controls.Add (_dataGrid);
+ ((ISupportInitialize)(_dataGrid)).EndInit ();
+ f.ResumeLayout (false);
+ f.Load += delegate (object sender, EventArgs e) { ((Control)sender).FindForm ().Close (); };
+
+ Application.Run (f);
+ }
+ }
+
+ [Test]
+ public void RowCountIncrease ()
+ {
+ DataGridView dgv = new DataGridView ();
+ dgv.RowCount = 3;
+
+ Assert.AreEqual (3, dgv.RowCount, "A1");
+ Assert.AreEqual (1, dgv.ColumnCount, "A2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "A3");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "A4");
+ Assert.AreEqual (2, dgv.Rows[2].Index, "A5");
+
+
+ dgv.RowCount = 2;
+
+ Assert.AreEqual (2, dgv.RowCount, "B1");
+ Assert.AreEqual (1, dgv.ColumnCount, "B2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "B3");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "B4");
+
+ dgv.RowCount = 6;
+
+ Assert.AreEqual (6, dgv.RowCount, "C1");
+ Assert.AreEqual (1, dgv.ColumnCount, "C2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "C3");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "C4");
+ Assert.AreEqual (2, dgv.Rows[2].Index, "C5");
+
+ dgv.AllowUserToAddRows = false;
+
+ Assert.AreEqual (5, dgv.RowCount, "D1");
+ Assert.AreEqual (1, dgv.ColumnCount, "D2");
+
+ dgv.RowCount = 1;
+
+ Assert.AreEqual (1, dgv.RowCount, "E1");
+ Assert.AreEqual (1, dgv.ColumnCount, "E2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "E3");
+
+ dgv.RowCount = 8;
+
+ Assert.AreEqual (8, dgv.RowCount, "F1");
+ Assert.AreEqual (1, dgv.ColumnCount, "F2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "F3");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "F4");
+ }
+
+ [Test]
+ public void RowCountDecrease ()
+ {
+ DataGridView dgv = new DataGridView ();
+ dgv.RowCount = 6;
+
+ Assert.AreEqual (6, dgv.RowCount, "A1");
+ Assert.AreEqual (1, dgv.ColumnCount, "A2");
+
+ dgv.RowCount = 3;
+ Assert.AreEqual (3, dgv.RowCount, "A3");
+ Assert.AreEqual (0, dgv.Rows[0].Index, "A4");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "A5");
+ Assert.AreEqual (2, dgv.Rows[2].Index, "A6");
+
+ try {
+ dgv.RowCount = 0;
+ Assert.Fail ("C1");
+ } catch {}
+
+
+ dgv.RowCount = 6;
+
+ Assert.AreEqual (6, dgv.RowCount, "B1");
+ Assert.AreEqual (1, dgv.ColumnCount, "B2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "B3");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "B4");
+ Assert.AreEqual (2, dgv.Rows[2].Index, "B5");
+
+
+ dgv.RowCount = 2;
+
+ Assert.AreEqual (2, dgv.RowCount, "C1");
+ Assert.AreEqual (1, dgv.ColumnCount, "C2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "C3");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "C4");
+
+ dgv.AllowUserToAddRows = false;
+
+ Assert.AreEqual (1, dgv.RowCount, "D1");
+ Assert.AreEqual (1, dgv.ColumnCount, "D2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "D3");
+
+ dgv.RowCount = 6;
+
+ Assert.AreEqual (6, dgv.RowCount, "E1");
+ Assert.AreEqual (1, dgv.ColumnCount, "E2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "E3");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "E4");
+ Assert.AreEqual (2, dgv.Rows[2].Index, "E5");
+
+
+ dgv.RowCount = 2;
+
+ Assert.AreEqual (2, dgv.RowCount, "F1");
+ Assert.AreEqual (1, dgv.ColumnCount, "F2");
+
+ Assert.AreEqual (0, dgv.Rows[0].Index, "F3");
+ Assert.AreEqual (1, dgv.Rows[1].Index, "F4");
+
+ }
+
+ [Test]
+ public void BindToReadonlyProperty ()
+ {
+ Form f = new Form ();
+ f.ShowInTaskbar = false;
+ DataGridView dgv = new DataGridView ();
+
+ List<cust> l = new List<cust> ();
+ l.Add (new cust ());
+
+ dgv.DataSource = l;
+ f.Controls.Add (dgv);
+
+ f.Show ();
+
+ Assert.AreEqual ("Name", dgv.Columns[0].Name, "A1");
+ Assert.AreEqual (true, dgv.Columns[0].ReadOnly, "A2");
+
+ f.Close ();
+ f.Dispose ();
+ }
+
+ class cust { public string Name { get { return "test"; } } }
+
+ [Test]
+ public void EnableHeadersVisualStylesDefaultValue ()
+ {
+ Assert.AreEqual (true, new DataGridView ().EnableHeadersVisualStyles);
+ }
+
+ [Test]
+ public void RowTemplate ()
+ {
+ DataGridView dgv = new DataGridView ();
+
+ Form f = new Form ();
+ f.Controls.Add (dgv);
+ f.Show ();
+
+ dgv.Columns.Add ("A1", "A1");
+ Assert.AreEqual (0, dgv.RowTemplate.Cells.Count, "A1");
+ Assert.IsNull (dgv.RowTemplate.DataGridView, "A2");
+
+ dgv.Columns.Add ("A2", "A2");
+ Assert.AreEqual (0, dgv.RowTemplate.Cells.Count, "A3");
+
+ dgv.Rows.Add (3, 6);
+
+ dgv.Columns.Remove ("A1");
+
+ Assert.AreEqual (0, dgv.RowTemplate.Cells.Count, "A4");
+ Assert.AreEqual (1, dgv.Rows[0].Cells.Count, "A5");
+
+ dgv.Columns.Clear ();
+
+ Assert.AreEqual (0, dgv.RowTemplate.Cells.Count, "A6");
+ Assert.AreEqual (0, dgv.Rows.Count, "A7");
+
+ f.Close ();
+ f.Dispose ();
+ }
+
+ [Test]
+ public void ScrollToSelectionSynchronous()
+ {
+ DataGridView dgv = new DataGridView ();
+ dgv.RowCount = 1000;
+ dgv.CurrentCell = dgv[0, dgv.RowCount -1];
+ Rectangle rowRect = dgv.GetRowDisplayRectangle (dgv.RowCount - 1, false);
+ Assert.AreEqual (true, dgv.DisplayRectangle.Contains (rowRect), "#01");
+ }
+
+ [Test]
+ public void CurrentCell()
+ {
+ DataGridView dgv = new DataGridView ();
+ dgv.AllowUserToAddRows = false;
+
+ Assert.IsNull (dgv.CurrentCell, "A1");
+
+ dgv.RowCount = 10;
+ dgv.ColumnCount = 2;
+ Assert.AreEqual (10, dgv.RowCount, "B1");
+ Assert.AreEqual (2, dgv.ColumnCount, "B2");
+ Assert.IsNull (dgv.CurrentCell, "B3");
+
+ dgv.CurrentCell = dgv[1, 9];
+ Assert.IsNotNull (dgv.CurrentCell, "H1");
+ Assert.AreEqual (9, dgv.CurrentCell.RowIndex, "H2");
+ Assert.AreEqual (1, dgv.CurrentCell.ColumnIndex, "H3");
+
+ dgv.CurrentCell = null;
+ Assert.IsNull (dgv.CurrentCell, "C1");
+
+ dgv.CurrentCell = dgv[1, 9];
+ Assert.IsNotNull (dgv.CurrentCell, "D1");
+ Assert.AreEqual (9, dgv.CurrentCell.RowIndex, "D2");
+ Assert.AreEqual (1, dgv.CurrentCell.ColumnIndex, "D3");
+
+ dgv.RowCount = 9;
+ Assert.IsNotNull (dgv.CurrentCell, "E1");
+ Assert.AreEqual (8, dgv.CurrentCell.RowIndex, "E2");
+ Assert.AreEqual (1, dgv.CurrentCell.ColumnIndex, "E3");
+
+ dgv.CurrentCell = dgv[0, 4];
+ dgv.RowCount = 2;
+ Assert.IsNotNull (dgv.CurrentCell, "F1");
+ Assert.AreEqual (1, dgv.CurrentCell.RowIndex, "F2");
+ Assert.AreEqual (0, dgv.CurrentCell.ColumnIndex, "F3");
+
+ dgv.RowCount = 0;
+ Assert.IsNull (dgv.CurrentCell, "P1");
+
+ dgv.RowCount = 10;
+ Assert.AreEqual (10, dgv.RowCount, "I1");
+ dgv.CurrentCell = dgv[0, 4];
+ dgv.ColumnCount = 0;
+ Assert.AreEqual (0, dgv.RowCount, "I2");
+ Assert.IsNull (dgv.CurrentCell, "I3");
+
+ dgv.RowCount = 0;
+ dgv.ColumnCount = 0;
+ dgv.CreateControl ();
+ dgv.ColumnCount = 2;
+ dgv.RowCount = 3;
+
+ Assert.IsNotNull (dgv.CurrentCell, "G1");
+ Assert.AreEqual (0, dgv.CurrentCell.RowIndex, "G1");
+ Assert.AreEqual (0, dgv.CurrentCell.ColumnIndex, "G1");
+ }
+
+ [Test]
+ public void DataSourceBindingContextDependency ()
+ {
+ List<DataItem> dataList = new List<DataItem> ();
+ dataList.Add (new DataItem ());
+ dataList.Add (new DataItem ());
+
+ DataGridView dgv = new DataGridView ();
+ dgv.DataSource = dataList;
+ Assert.IsNull (dgv.BindingContext, "#1");
+ Assert.IsFalse (dgv.IsHandleCreated, "#2");
+ Assert.AreEqual (0, dgv.RowCount, "#3");
+
+ dgv.DataSource = null;
+
+ Form form = new Form ();
+ form.Controls.Add (dgv);
+ dgv.DataSource = dataList;
+
+ Assert.IsNotNull (dgv.BindingContext, "#4");
+ Assert.IsFalse (dgv.IsHandleCreated, "#5");
+ Assert.AreEqual (2, dgv.RowCount, "#6");
+
+ dgv.Dispose ();
+ dgv = new DataGridView ();
+ dgv.DataSource = dataList;
+
+ Assert.IsNull (dgv.BindingContext, "#7");
+ Assert.IsFalse (dgv.IsHandleCreated, "#8");
+ Assert.AreEqual (0, dgv.RowCount, "#9");
+
+ dgv.CreateControl ();
+
+ Assert.IsNull (dgv.BindingContext, "#10");
+ Assert.IsTrue (dgv.IsHandleCreated, "#11");
+ Assert.AreEqual (0, dgv.RowCount, "#12");
+ }
+
+ [Test]
+ public void RowTemplateDataGridView ()
+ {
+ DataGridView gdv = new DataGridView ();
+ Assert.IsNull (gdv.RowTemplate.DataGridView, "#1");
+ }
+ }
+
+ [TestFixture]
+ public class DataGridViewControlCollectionTest
+ {
+ [Test]
+ public void TestClear ()
+ {
+ using (DataGridView dgv = new DataGridView ()) {
+ DataGridView.DataGridViewControlCollection controls = (DataGridView.DataGridViewControlCollection) dgv.Controls;
+ Control c1 = new Control ();
+ Control c2 = new Control ();
+ Control c3 = new Control ();
+ Assert.AreEqual (2, controls.Count, "#02");
+ controls.Add (c1);
+ controls.Add (c2);
+ controls.Add (c3);
+ Assert.AreEqual (5, controls.Count, "#02");
+ controls.Clear ();
+ Assert.AreEqual (3, controls.Count, "#03");
+ Assert.AreSame (c2, controls [2], "#04");
+ }
+
+ // Maybe MS should start writing unit-tests?
+
+ using (DataGridView dgv = new DataGridView ()) {
+ DataGridView.DataGridViewControlCollection controls = (DataGridView.DataGridViewControlCollection)dgv.Controls;
+ Control [] c = new Control [20];
+ for (int i = 0; i < c.Length; i++) {
+ c [i] = new Control ();
+ c [i].Text = "#" + i.ToString ();
+ }
+
+ Assert.AreEqual (2, controls.Count, "#02");
+ controls.AddRange (c);
+ Assert.AreEqual (22, controls.Count, "#02");
+ controls.Clear ();
+ Assert.AreEqual (12, controls.Count, "#03");
+
+ for (int i = 0; i < c.Length; i += 2) {
+ Assert.AreSame (c [i+1], controls [ (i / 2) + 2], "#A" + i.ToString ());
+ }
+ }
+ }
+
+ [Test]
+ public void TestCopyTo ()
+ {
+ using (DataGridView dgv = new DataGridView ()) {
+ DataGridView.DataGridViewControlCollection controls = (DataGridView.DataGridViewControlCollection)dgv.Controls;
+ Control c1 = new Control ();
+ Control c2 = new Control ();
+ Control c3 = new Control ();
+ Control [] copy = new Control [10];
+ Assert.AreEqual (2, controls.Count, "#01");
+ controls.AddRange (new Control [] { c1, c2, c3 });
+ Assert.AreEqual (5, controls.Count, "#01-b");
+ controls.CopyTo (copy, 0);
+ Assert.AreEqual (5, controls.Count, "#02");
+ Assert.AreEqual (10, copy.Length, "#03");
+ for (int i = 0; i < copy.Length; i++) {
+ if (i >= 5)
+ Assert.IsNull (copy [i], "#A" + i.ToString ());
+ else
+ Assert.IsNotNull (copy [i], "#B" + i.ToString ());
+ }
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (NotSupportedException))]
+ public void TestInsert ()
+ {
+ using (DataGridView dgv = new DataGridView ()) {
+ DataGridView.DataGridViewControlCollection controls = (DataGridView.DataGridViewControlCollection)dgv.Controls;
+ controls.Insert (1, new Control ());
+ }
+ }
+
+ [Test]
+ public void TestRemove ()
+ {
+ using (DataGridView dgv = new DataGridView ()) {
+ DataGridView.DataGridViewControlCollection controls = (DataGridView.DataGridViewControlCollection)dgv.Controls;
+ Control c1 = new Control ();
+ Control c2 = new Control ();
+ Control c3 = new Control ();
+ Control [] copy = new Control [10];
+
+ controls.AddRange (new Control [] {c1, c2, c3});
+
+ controls.Remove (c2);
+ Assert.AreEqual (4, controls.Count, "#01");
+ controls.Remove (c2);
+ Assert.AreEqual (4, controls.Count, "#02");
+ controls.Remove (c1);
+ Assert.AreEqual (3, controls.Count, "#03");
+ controls.Remove (c3);
+ Assert.AreEqual (2, controls.Count, "#04");
+
+ controls.Remove (controls [0]);
+ controls.Remove (controls [1]);
+ Assert.AreEqual (2, controls.Count, "#05");
+ }
+ }
}
+
}
#endif
projects / mono.git / blobdiff