plugins/ui-designer/testSrc/com/intellij/uiDesigner/GridChangeUtilTest.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2009 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.uiDesigner;

 import com.intellij.uiDesigner.core.GridConstraints;
 import com.intellij.uiDesigner.core.GridLayoutManager;
 import com.intellij.uiDesigner.radComponents.RadContainer;
 import com.intellij.uiDesigner.radComponents.RadHSpacer;
 import junit.framework.TestCase;

 import java.awt.Insets;
 import java.awt.LayoutManager;

 public final class GridChangeUtilTest extends TestCase {

   public void test_margins_and_gaps() {
     final Insets margin = new Insets(11,12,13,14);

     final int hGap = 15;
     final int vGap = 16;
     final RadContainer grid = createGrid(2, 3, margin, hGap, vGap);

     {
       final LayoutManager oldLayout = grid.getLayout();
       GridChangeUtil.insertRowOrColumn(grid, 1, false, false);
       final GridLayoutManager newLayout = (GridLayoutManager)grid.getLayout();

       assertGridDimensions(grid, 2, 4);
       assertTrue(oldLayout != newLayout);
       assertTrue(margin != newLayout.getMargin());
       assertEquals(margin, newLayout.getMargin());
       assertEquals(hGap, newLayout.getHGap());
       assertEquals(vGap, newLayout.getVGap());
     }

     {
       final LayoutManager oldLayout = grid.getLayout();
       GridChangeUtil.splitRow(grid, 1);
       final GridLayoutManager newLayout = (GridLayoutManager)grid.getLayout();

       assertGridDimensions(grid, 3, 4);
       assertTrue(oldLayout != newLayout);
       assertTrue(margin != newLayout.getMargin());
       assertEquals(margin, newLayout.getMargin());
       assertEquals(hGap, newLayout.getHGap());
       assertEquals(vGap, newLayout.getVGap());
     }
   }

   public void test_invalid_parameters() throws Exception{
     final RadContainer grid = SampleGrid.create();

     try {
       // should cause exception
       GridChangeUtil.splitRow(grid, -1);
       assertTrue(false);
     }
     catch (IllegalArgumentException ok) {
     }

     try {
       // should cause exception
       GridChangeUtil.splitRow(grid, SampleGrid.ORIGINAL_ROWS);
       assertTrue(false);
     }
     catch (IllegalArgumentException ok) {
     }

     // should be ok
     GridChangeUtil.splitRow(grid, SampleGrid.ORIGINAL_ROWS - 1);
     assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS + 1, SampleGrid.ORIGINAL_COLUMNS);

     try {
       // should cause exception
       GridChangeUtil.splitColumn(grid, -1);
       assertTrue(false);
     }
     catch (IllegalArgumentException ok) {
     }

     try {
       // should cause exception
       GridChangeUtil.splitColumn(grid, SampleGrid.ORIGINAL_COLUMNS);
       assertTrue(false);
     }
     catch (IllegalArgumentException ok) {
     }

     // should be ok
     GridChangeUtil.splitColumn(grid, SampleGrid.ORIGINAL_COLUMNS - 1);
     assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS + 1, SampleGrid.ORIGINAL_COLUMNS + 1);

     try {
       // should cause exception
       GridChangeUtil.canDeleteCell(grid, -1, false);
       assertTrue(false);
     }
     catch (IllegalArgumentException ok) {
     }

     try {
       // should cause exception
       GridChangeUtil.canDeleteCell(grid, ((GridLayoutManager)grid.getLayout()).getColumnCount(), false);
       assertTrue(false);
     }
     catch (IllegalArgumentException ok) {
     }
   }

   /**
    * 0 0 0 - -
    * - 1 1 1 -
    * 2 2 2 2 -
    * - 3 - - -
    * - - 4 4 4
    * 5 - - - -
    */
   private static final class SampleGrid {
     public static final int ORIGINAL_ROWS = 6;
     public static final int ORIGINAL_COLUMNS = 5;

     public static final int C0 = 0;
     public static final int C1 = 1;
     public static final int C2 = 0;
     public static final int C3 = 1;
     public static final int C4 = 2;
     public static final int C5 = 0;

     public static final int S0 = 3;
     public static final int S1 = 3;
     public static final int S2 = 4;
     public static final int S3 = 1;
     public static final int S4 = 3;
     public static final int S5 = 1;

     public static RadContainer create() throws Exception{

       final RadContainer grid = createGrid(ORIGINAL_ROWS, ORIGINAL_COLUMNS);

       addComponent(0, C0, S0, grid);
       addComponent(1, C1, S1, grid);
       addComponent(2, C2, S2, grid);
       addComponent(3, C3, S3, grid);
       addComponent(4, C4, S4, grid);
       addComponent(5, C5, S5, grid);

       return grid;
     }

     private static void addComponent(final int idx, final int cell, final int span, final RadContainer grid) {
       final RadHSpacer component = new RadHSpacer(null, Integer.toString(idx));
       component.getConstraints().restore(new GridConstraints(idx, cell, 1, span, GridConstraints.ANCHOR_CENTER, GridConstraints.FILL_BOTH, 0,0,null,null,null,
                                                              0));
       grid.addComponent(component);
     }
   }

   public void test_split() throws Exception{
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.splitColumn(grid, 1);
     assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

     assertComponentCellAndSpan(grid, 0, 0, 4);
     assertComponentCellAndSpan(grid, 1, 1, 4);
     assertComponentCellAndSpan(grid, 2, 0, 5);
     assertComponentCellAndSpan(grid, 3, 1, 2);
     assertComponentCellAndSpan(grid, 4, 3, 3);
     assertComponentCellAndSpan(grid, 5, 0, 1);
   }

   public void test_insert_1() throws Exception{
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.insertRowOrColumn(grid, 1, false, false);
     assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

     assertComponentCellAndSpan(grid, 0, 0, 4);
     assertComponentCellAndSpan(grid, 1, 1, 4);
     assertComponentCellAndSpan(grid, 2, 0, 5);
     assertComponentCellAndSpan(grid, 3, 1, 1);
     assertComponentCellAndSpan(grid, 4, 3, 3);
     assertComponentCellAndSpan(grid, 5, 0, 1);
   }

   @SuppressWarnings({"PointlessArithmeticExpression"})
   public void test_insert_first() throws Exception{
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.insertRowOrColumn(grid, 0, false, true);
     assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

     // all must be shifted one cell right
     assertComponentCellAndSpan(grid, 0, SampleGrid.C0 + 1, SampleGrid.S0);
     assertComponentCellAndSpan(grid, 1, SampleGrid.C1 + 1, SampleGrid.S1);
     assertComponentCellAndSpan(grid, 2, SampleGrid.C2 + 1, SampleGrid.S2);
     assertComponentCellAndSpan(grid, 3, SampleGrid.C3 + 1, SampleGrid.S3);
     assertComponentCellAndSpan(grid, 4, SampleGrid.C4 + 1, SampleGrid.S4);
     assertComponentCellAndSpan(grid, 5, SampleGrid.C5 + 1, SampleGrid.S5);
   }

   public void test_insert_last() throws Exception{
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.insertRowOrColumn(grid, SampleGrid.ORIGINAL_COLUMNS-1, false, false);
     assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

     // no component should change its cell or span
     assertComponentCellAndSpan(grid, 0, SampleGrid.C0, SampleGrid.S0);
     assertComponentCellAndSpan(grid, 1, SampleGrid.C1, SampleGrid.S1);
     assertComponentCellAndSpan(grid, 2, SampleGrid.C2, SampleGrid.S2);
     assertComponentCellAndSpan(grid, 3, SampleGrid.C3, SampleGrid.S3);
     assertComponentCellAndSpan(grid, 4, SampleGrid.C4, SampleGrid.S4);
     assertComponentCellAndSpan(grid, 5, SampleGrid.C5, SampleGrid.S5);
   }

   public void test_insert_after_and_before() throws Exception{
     for (int i=0; i < SampleGrid.ORIGINAL_COLUMNS-1; i++){
       final RadContainer afterCurrent = SampleGrid.create();
       GridChangeUtil.insertRowOrColumn(afterCurrent, i, false, false);
       assertGridDimensions(afterCurrent, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

       final RadContainer beforeNext = SampleGrid.create();
       GridChangeUtil.insertRowOrColumn(beforeNext, i+1, false, true);
       assertGridDimensions(beforeNext, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

       // afterCurrent and beforeNext grids should be same
       assertGridsEqual(afterCurrent, beforeNext);
     }
   }

   public void test_delete() throws Exception{
     {
       final RadContainer grid = SampleGrid.create();

       assertEquals(GridChangeUtil.CellStatus.Required, GridChangeUtil.canDeleteCell(grid, 0, false));
       assertEquals(GridChangeUtil.CellStatus.Required, GridChangeUtil.canDeleteCell(grid, 1, false));
       assertEquals(GridChangeUtil.CellStatus.CanShift, GridChangeUtil.canDeleteCell(grid, 2, false));
       assertEquals(GridChangeUtil.CellStatus.Redundant, GridChangeUtil.canDeleteCell(grid, 3, false));
       assertEquals(GridChangeUtil.CellStatus.Redundant, GridChangeUtil.canDeleteCell(grid, 4, false));
     }

     for (int i=0; i < SampleGrid.ORIGINAL_COLUMNS; i++){
       final RadContainer grid = SampleGrid.create();

       if (GridChangeUtil.canDeleteCell(grid, i, false) != GridChangeUtil.CellStatus.Required) {
         GridChangeUtil.deleteCell(grid, i, false);
         assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS - 1);
       }
       else {
         // exception should be thrown
         try {
           GridChangeUtil.deleteCell(grid, i, false);
           assertTrue(false);
         }
         catch (IllegalArgumentException ok) {
         }
       }
     }

     // no rows in SampleGrid should be deletable...
     {
       final RadContainer grid = SampleGrid.create();
       for (int i=0; i < SampleGrid.ORIGINAL_ROWS; i++){
         assertEquals(GridChangeUtil.CellStatus.Required, GridChangeUtil.canDeleteCell(grid, i, true));
       }
     }
   }

   public void testMoveRowDown() throws Exception {
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.moveCells(grid, true, new int[] { 3 }, 6);
     assertEquals(5, grid.getComponent(3).getConstraints().getRow());
     assertEquals(3, grid.getComponent(4).getConstraints().getRow());
     assertEquals(4, grid.getComponent(5).getConstraints().getRow());
   }

   public void testMoveRowUp() throws Exception {
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.moveCells(grid, true, new int[] { 5 }, 3);
     assertEquals(4, grid.getComponent(3).getConstraints().getRow());
     assertEquals(5, grid.getComponent(4).getConstraints().getRow());
     assertEquals(3, grid.getComponent(5).getConstraints().getRow());
   }

   public void testMoveAdjacentRowsDown() throws Exception {
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.moveCells(grid, true, new int[] { 3, 4 }, 6);
     assertEquals(4, grid.getComponent(3).getConstraints().getRow());
     assertEquals(5, grid.getComponent(4).getConstraints().getRow());
     assertEquals(3, grid.getComponent(5).getConstraints().getRow());
   }

   public void testMoveAdjacentRowsUp() throws Exception {
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.moveCells(grid, true, new int[] { 4, 5 }, 3);
     assertEquals(5, grid.getComponent(3).getConstraints().getRow());
     assertEquals(3, grid.getComponent(4).getConstraints().getRow());
     assertEquals(4, grid.getComponent(5).getConstraints().getRow());
   }

   public void testMoveDisjointRowsDown() throws Exception {
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.moveCells(grid, true, new int[] { 0, 2 }, 5);
     assertEquals(3, grid.getComponent(0).getConstraints().getRow());
     assertEquals(4, grid.getComponent(2).getConstraints().getRow());
     assertEquals(1, grid.getComponent(3).getConstraints().getRow());
   }

   public void testMoveDisjointRowsUp() throws Exception {
     final RadContainer grid = SampleGrid.create();
     GridChangeUtil.moveCells(grid, true, new int[] { 2, 4 }, 0);
     assertEquals(0, grid.getComponent(2).getConstraints().getRow());
     assertEquals(1, grid.getComponent(4).getConstraints().getRow());
     assertEquals(2, grid.getComponent(0).getConstraints().getRow());
     assertEquals(3, grid.getComponent(1).getConstraints().getRow());
   }

   private static void assertGridsEqual(final RadContainer gridA, final RadContainer gridB){
     final int count = gridA.getComponentCount();
     assertEquals(count, gridB.getComponentCount());

     for (int j = 0; j < count; j++) {
       final GridConstraints aConstraints = gridA.getComponent(j).getConstraints();
       final GridConstraints bConstraints = gridB.getComponent(j).getConstraints();

       assertEquals(aConstraints.getColumn(), bConstraints.getColumn());
       assertEquals(aConstraints.getColSpan(), bConstraints.getColSpan());
     }
   }

   private static RadContainer createGrid(final int rowCount, final int columnCount){
     return createGrid(rowCount, columnCount, new Insets(0,0,0,0), 0, 0);
   }

   private static RadContainer createGrid(final int rowCount, final int columnCount, final Insets margin, final int hGap, final int vGap){
     final RadContainer container = new RadContainer(null, "grid");
     container.setLayout(new GridLayoutManager(rowCount,columnCount,margin, hGap, vGap));
     return container;
   }

   private static void assertGridDimensions(final RadContainer grid, final int rowCount, final int columnCount) {
     final GridLayoutManager layout = (GridLayoutManager)grid.getLayout();
     assertEquals(columnCount, layout.getColumnCount());
     assertEquals(rowCount, layout.getRowCount());
   }

   private static void assertComponentCellAndSpan(final RadContainer grid, final int idx, final int cell, final int span){
     final GridConstraints constraints = grid.getComponent(idx).getConstraints();
     assertEquals(cell, constraints.getColumn());
     assertEquals(span, constraints.getColSpan());
   }
 }
	/*
	* Copyright 2000-2009 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.uiDesigner;

	import com.intellij.uiDesigner.core.GridConstraints;
	import com.intellij.uiDesigner.core.GridLayoutManager;
	import com.intellij.uiDesigner.radComponents.RadContainer;
	import com.intellij.uiDesigner.radComponents.RadHSpacer;
	import junit.framework.TestCase;

	import java.awt.Insets;
	import java.awt.LayoutManager;

	public final class GridChangeUtilTest extends TestCase {

	public void test_margins_and_gaps() {
	final Insets margin = new Insets(11,12,13,14);

	final int hGap = 15;
	final int vGap = 16;
	final RadContainer grid = createGrid(2, 3, margin, hGap, vGap);

	{
	final LayoutManager oldLayout = grid.getLayout();
	GridChangeUtil.insertRowOrColumn(grid, 1, false, false);
	final GridLayoutManager newLayout = (GridLayoutManager)grid.getLayout();

	assertGridDimensions(grid, 2, 4);
	assertTrue(oldLayout != newLayout);
	assertTrue(margin != newLayout.getMargin());
	assertEquals(margin, newLayout.getMargin());
	assertEquals(hGap, newLayout.getHGap());
	assertEquals(vGap, newLayout.getVGap());
	}

	{
	final LayoutManager oldLayout = grid.getLayout();
	GridChangeUtil.splitRow(grid, 1);
	final GridLayoutManager newLayout = (GridLayoutManager)grid.getLayout();

	assertGridDimensions(grid, 3, 4);
	assertTrue(oldLayout != newLayout);
	assertTrue(margin != newLayout.getMargin());
	assertEquals(margin, newLayout.getMargin());
	assertEquals(hGap, newLayout.getHGap());
	assertEquals(vGap, newLayout.getVGap());
	}
	}

	public void test_invalid_parameters() throws Exception{
	final RadContainer grid = SampleGrid.create();

	try {
	// should cause exception
	GridChangeUtil.splitRow(grid, -1);
	assertTrue(false);
	}
	catch (IllegalArgumentException ok) {
	}

	try {
	// should cause exception
	GridChangeUtil.splitRow(grid, SampleGrid.ORIGINAL_ROWS);
	assertTrue(false);
	}
	catch (IllegalArgumentException ok) {
	}

	// should be ok
	GridChangeUtil.splitRow(grid, SampleGrid.ORIGINAL_ROWS - 1);
	assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS + 1, SampleGrid.ORIGINAL_COLUMNS);

	try {
	// should cause exception
	GridChangeUtil.splitColumn(grid, -1);
	assertTrue(false);
	}
	catch (IllegalArgumentException ok) {
	}

	try {
	// should cause exception
	GridChangeUtil.splitColumn(grid, SampleGrid.ORIGINAL_COLUMNS);
	assertTrue(false);
	}
	catch (IllegalArgumentException ok) {
	}

	// should be ok
	GridChangeUtil.splitColumn(grid, SampleGrid.ORIGINAL_COLUMNS - 1);
	assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS + 1, SampleGrid.ORIGINAL_COLUMNS + 1);

	try {
	// should cause exception
	GridChangeUtil.canDeleteCell(grid, -1, false);
	assertTrue(false);
	}
	catch (IllegalArgumentException ok) {
	}

	try {
	// should cause exception
	GridChangeUtil.canDeleteCell(grid, ((GridLayoutManager)grid.getLayout()).getColumnCount(), false);
	assertTrue(false);
	}
	catch (IllegalArgumentException ok) {
	}
	}

	/**
	* 0 0 0 - -
	* - 1 1 1 -
	* 2 2 2 2 -
	* - 3 - - -
	* - - 4 4 4
	* 5 - - - -
	*/
	private static final class SampleGrid {
	public static final int ORIGINAL_ROWS = 6;
	public static final int ORIGINAL_COLUMNS = 5;

	public static final int C0 = 0;
	public static final int C1 = 1;
	public static final int C2 = 0;
	public static final int C3 = 1;
	public static final int C4 = 2;
	public static final int C5 = 0;

	public static final int S0 = 3;
	public static final int S1 = 3;
	public static final int S2 = 4;
	public static final int S3 = 1;
	public static final int S4 = 3;
	public static final int S5 = 1;

	public static RadContainer create() throws Exception{

	final RadContainer grid = createGrid(ORIGINAL_ROWS, ORIGINAL_COLUMNS);

	addComponent(0, C0, S0, grid);
	addComponent(1, C1, S1, grid);
	addComponent(2, C2, S2, grid);
	addComponent(3, C3, S3, grid);
	addComponent(4, C4, S4, grid);
	addComponent(5, C5, S5, grid);

	return grid;
	}

	private static void addComponent(final int idx, final int cell, final int span, final RadContainer grid) {
	final RadHSpacer component = new RadHSpacer(null, Integer.toString(idx));
	component.getConstraints().restore(new GridConstraints(idx, cell, 1, span, GridConstraints.ANCHOR_CENTER, GridConstraints.FILL_BOTH, 0,0,null,null,null,
	0));
	grid.addComponent(component);
	}
	}

	public void test_split() throws Exception{
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.splitColumn(grid, 1);
	assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

	assertComponentCellAndSpan(grid, 0, 0, 4);
	assertComponentCellAndSpan(grid, 1, 1, 4);
	assertComponentCellAndSpan(grid, 2, 0, 5);
	assertComponentCellAndSpan(grid, 3, 1, 2);
	assertComponentCellAndSpan(grid, 4, 3, 3);
	assertComponentCellAndSpan(grid, 5, 0, 1);
	}

	public void test_insert_1() throws Exception{
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.insertRowOrColumn(grid, 1, false, false);
	assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

	assertComponentCellAndSpan(grid, 0, 0, 4);
	assertComponentCellAndSpan(grid, 1, 1, 4);
	assertComponentCellAndSpan(grid, 2, 0, 5);
	assertComponentCellAndSpan(grid, 3, 1, 1);
	assertComponentCellAndSpan(grid, 4, 3, 3);
	assertComponentCellAndSpan(grid, 5, 0, 1);
	}

	@SuppressWarnings({"PointlessArithmeticExpression"})
	public void test_insert_first() throws Exception{
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.insertRowOrColumn(grid, 0, false, true);
	assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

	// all must be shifted one cell right
	assertComponentCellAndSpan(grid, 0, SampleGrid.C0 + 1, SampleGrid.S0);
	assertComponentCellAndSpan(grid, 1, SampleGrid.C1 + 1, SampleGrid.S1);
	assertComponentCellAndSpan(grid, 2, SampleGrid.C2 + 1, SampleGrid.S2);
	assertComponentCellAndSpan(grid, 3, SampleGrid.C3 + 1, SampleGrid.S3);
	assertComponentCellAndSpan(grid, 4, SampleGrid.C4 + 1, SampleGrid.S4);
	assertComponentCellAndSpan(grid, 5, SampleGrid.C5 + 1, SampleGrid.S5);
	}

	public void test_insert_last() throws Exception{
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.insertRowOrColumn(grid, SampleGrid.ORIGINAL_COLUMNS-1, false, false);
	assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

	// no component should change its cell or span
	assertComponentCellAndSpan(grid, 0, SampleGrid.C0, SampleGrid.S0);
	assertComponentCellAndSpan(grid, 1, SampleGrid.C1, SampleGrid.S1);
	assertComponentCellAndSpan(grid, 2, SampleGrid.C2, SampleGrid.S2);
	assertComponentCellAndSpan(grid, 3, SampleGrid.C3, SampleGrid.S3);
	assertComponentCellAndSpan(grid, 4, SampleGrid.C4, SampleGrid.S4);
	assertComponentCellAndSpan(grid, 5, SampleGrid.C5, SampleGrid.S5);
	}

	public void test_insert_after_and_before() throws Exception{
	for (int i=0; i < SampleGrid.ORIGINAL_COLUMNS-1; i++){
	final RadContainer afterCurrent = SampleGrid.create();
	GridChangeUtil.insertRowOrColumn(afterCurrent, i, false, false);
	assertGridDimensions(afterCurrent, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

	final RadContainer beforeNext = SampleGrid.create();
	GridChangeUtil.insertRowOrColumn(beforeNext, i+1, false, true);
	assertGridDimensions(beforeNext, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS + 1);

	// afterCurrent and beforeNext grids should be same
	assertGridsEqual(afterCurrent, beforeNext);
	}
	}

	public void test_delete() throws Exception{
	{
	final RadContainer grid = SampleGrid.create();

	assertEquals(GridChangeUtil.CellStatus.Required, GridChangeUtil.canDeleteCell(grid, 0, false));
	assertEquals(GridChangeUtil.CellStatus.Required, GridChangeUtil.canDeleteCell(grid, 1, false));
	assertEquals(GridChangeUtil.CellStatus.CanShift, GridChangeUtil.canDeleteCell(grid, 2, false));
	assertEquals(GridChangeUtil.CellStatus.Redundant, GridChangeUtil.canDeleteCell(grid, 3, false));
	assertEquals(GridChangeUtil.CellStatus.Redundant, GridChangeUtil.canDeleteCell(grid, 4, false));
	}

	for (int i=0; i < SampleGrid.ORIGINAL_COLUMNS; i++){
	final RadContainer grid = SampleGrid.create();

	if (GridChangeUtil.canDeleteCell(grid, i, false) != GridChangeUtil.CellStatus.Required) {
	GridChangeUtil.deleteCell(grid, i, false);
	assertGridDimensions(grid, SampleGrid.ORIGINAL_ROWS, SampleGrid.ORIGINAL_COLUMNS - 1);
	}
	else {
	// exception should be thrown
	try {
	GridChangeUtil.deleteCell(grid, i, false);
	assertTrue(false);
	}
	catch (IllegalArgumentException ok) {
	}
	}
	}

	// no rows in SampleGrid should be deletable...
	{
	final RadContainer grid = SampleGrid.create();
	for (int i=0; i < SampleGrid.ORIGINAL_ROWS; i++){
	assertEquals(GridChangeUtil.CellStatus.Required, GridChangeUtil.canDeleteCell(grid, i, true));
	}
	}
	}

	public void testMoveRowDown() throws Exception {
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.moveCells(grid, true, new int[] { 3 }, 6);
	assertEquals(5, grid.getComponent(3).getConstraints().getRow());
	assertEquals(3, grid.getComponent(4).getConstraints().getRow());
	assertEquals(4, grid.getComponent(5).getConstraints().getRow());
	}

	public void testMoveRowUp() throws Exception {
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.moveCells(grid, true, new int[] { 5 }, 3);
	assertEquals(4, grid.getComponent(3).getConstraints().getRow());
	assertEquals(5, grid.getComponent(4).getConstraints().getRow());
	assertEquals(3, grid.getComponent(5).getConstraints().getRow());
	}

	public void testMoveAdjacentRowsDown() throws Exception {
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.moveCells(grid, true, new int[] { 3, 4 }, 6);
	assertEquals(4, grid.getComponent(3).getConstraints().getRow());
	assertEquals(5, grid.getComponent(4).getConstraints().getRow());
	assertEquals(3, grid.getComponent(5).getConstraints().getRow());
	}

	public void testMoveAdjacentRowsUp() throws Exception {
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.moveCells(grid, true, new int[] { 4, 5 }, 3);
	assertEquals(5, grid.getComponent(3).getConstraints().getRow());
	assertEquals(3, grid.getComponent(4).getConstraints().getRow());
	assertEquals(4, grid.getComponent(5).getConstraints().getRow());
	}

	public void testMoveDisjointRowsDown() throws Exception {
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.moveCells(grid, true, new int[] { 0, 2 }, 5);
	assertEquals(3, grid.getComponent(0).getConstraints().getRow());
	assertEquals(4, grid.getComponent(2).getConstraints().getRow());
	assertEquals(1, grid.getComponent(3).getConstraints().getRow());
	}

	public void testMoveDisjointRowsUp() throws Exception {
	final RadContainer grid = SampleGrid.create();
	GridChangeUtil.moveCells(grid, true, new int[] { 2, 4 }, 0);
	assertEquals(0, grid.getComponent(2).getConstraints().getRow());
	assertEquals(1, grid.getComponent(4).getConstraints().getRow());
	assertEquals(2, grid.getComponent(0).getConstraints().getRow());
	assertEquals(3, grid.getComponent(1).getConstraints().getRow());
	}

	private static void assertGridsEqual(final RadContainer gridA, final RadContainer gridB){
	final int count = gridA.getComponentCount();
	assertEquals(count, gridB.getComponentCount());

	for (int j = 0; j < count; j++) {
	final GridConstraints aConstraints = gridA.getComponent(j).getConstraints();
	final GridConstraints bConstraints = gridB.getComponent(j).getConstraints();

	assertEquals(aConstraints.getColumn(), bConstraints.getColumn());
	assertEquals(aConstraints.getColSpan(), bConstraints.getColSpan());
	}
	}

	private static RadContainer createGrid(final int rowCount, final int columnCount){
	return createGrid(rowCount, columnCount, new Insets(0,0,0,0), 0, 0);
	}

	private static RadContainer createGrid(final int rowCount, final int columnCount, final Insets margin, final int hGap, final int vGap){
	final RadContainer container = new RadContainer(null, "grid");
	container.setLayout(new GridLayoutManager(rowCount,columnCount,margin, hGap, vGap));
	return container;
	}

	private static void assertGridDimensions(final RadContainer grid, final int rowCount, final int columnCount) {
	final GridLayoutManager layout = (GridLayoutManager)grid.getLayout();
	assertEquals(columnCount, layout.getColumnCount());
	assertEquals(rowCount, layout.getRowCount());
	}

	private static void assertComponentCellAndSpan(final RadContainer grid, final int idx, final int cell, final int span){
	final GridConstraints constraints = grid.getComponent(idx).getConstraints();
	assertEquals(cell, constraints.getColumn());
	assertEquals(span, constraints.getColSpan());
	}
	}