| /* |
| * Copyright 2008 Google Inc. |
| * |
| * 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.google.gwt.user.client.ui; |
| |
| import com.google.gwt.event.logical.shared.BeforeSelectionEvent; |
| import com.google.gwt.event.logical.shared.BeforeSelectionHandler; |
| import com.google.gwt.event.logical.shared.SelectionEvent; |
| import com.google.gwt.event.logical.shared.SelectionHandler; |
| import com.google.gwt.junit.client.GWTTestCase; |
| import com.google.gwt.safehtml.shared.SafeHtmlUtils; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Element; |
| |
| /** |
| * Tests the {@link TabBar} widget. |
| */ |
| public class TabBarTest extends GWTTestCase { |
| |
| private class TestSelectionHandler implements |
| BeforeSelectionHandler<Integer>, SelectionHandler<Integer> { |
| private boolean onBeforeSelectionFired; |
| private boolean onSelectionFired; |
| |
| public void assertOnBeforeSelectionFired(boolean expected) { |
| assertEquals(expected, onBeforeSelectionFired); |
| } |
| |
| public void assertOnSelectionFired(boolean expected) { |
| assertEquals(expected, onSelectionFired); |
| } |
| |
| public void onBeforeSelection(BeforeSelectionEvent<Integer> event) { |
| assertFalse(onSelectionFired); |
| onBeforeSelectionFired = true; |
| } |
| |
| public void onSelection(SelectionEvent<Integer> event) { |
| assertTrue(onBeforeSelectionFired); |
| onSelectionFired = true; |
| } |
| } |
| |
| private static final String html = "<b>hello</b><i>world</i>"; |
| |
| int selected; |
| int beforeSelection; |
| |
| @Override |
| public String getModuleName() { |
| return "com.google.gwt.user.DebugTest"; |
| } |
| |
| public void testAddTab() { |
| TabBar bar = createTabBar(); |
| bar.addTab(SafeHtmlUtils.fromSafeConstant(html)); |
| |
| assertEquals(html, bar.getTabHTML(0).toLowerCase()); |
| } |
| |
| public void testDebugId() { |
| // Create a tab bar with a few tabs |
| TabBar bar = createTabBar(); |
| Label tab0 = new Label("My Tab 0"); |
| bar.addTab(tab0); |
| Label tab1 = new Label("My Tab 1"); |
| bar.addTab(tab1); |
| Label tab2 = new Label("My Tab 2"); |
| bar.addTab(tab2); |
| |
| // Verify the debug IDs are on the correct elements |
| bar.ensureDebugId("myBar"); |
| HorizontalPanel hPanel = (HorizontalPanel) bar.getWidget(); |
| Element tr = DOM.getFirstChild(hPanel.getBody()); |
| UIObjectTest.assertDebugId("myBar", bar.getElement()); |
| UIObjectTest.assertDebugId("myBar-tab0", DOM.getParent(tab0.getElement())); |
| UIObjectTest.assertDebugId("myBar-tab-wrapper0", DOM.getChild(tr, 1)); |
| UIObjectTest.assertDebugId("myBar-tab1", DOM.getParent(tab1.getElement())); |
| UIObjectTest.assertDebugId("myBar-tab-wrapper1", DOM.getChild(tr, 2)); |
| UIObjectTest.assertDebugId("myBar-tab2", DOM.getParent(tab2.getElement())); |
| UIObjectTest.assertDebugId("myBar-tab-wrapper2", DOM.getChild(tr, 3)); |
| } |
| |
| public void testEnableDisable() { |
| final TabBar bar = createTabBar(); |
| bar.addTab("foo"); |
| bar.addTab("bar"); |
| bar.addTab("baz"); |
| |
| assertTrue(bar.isTabEnabled(1)); |
| bar.setTabEnabled(1, false); |
| assertFalse(bar.isTabEnabled(1)); |
| bar.setTabEnabled(1, true); |
| assertTrue(bar.isTabEnabled(1)); |
| } |
| |
| public void testInsertTab() { |
| TabBar bar = createTabBar(); |
| bar.insertTab(SafeHtmlUtils.fromSafeConstant(html), 0); |
| |
| assertEquals(html, bar.getTabHTML(0).toLowerCase()); |
| } |
| |
| public void testSelect() { |
| // Create a tab bar with three items. |
| final TabBar bar = createTabBar(); |
| bar.addTab("foo"); |
| bar.addTab("bar"); |
| bar.addTab("baz"); |
| bar.selectTab(1); |
| assertEquals(1, bar.getSelectedTab()); |
| bar.selectTab(2); |
| assertEquals(2, bar.getSelectedTab()); |
| bar.selectTab(-1); |
| assertEquals(-1, bar.getSelectedTab()); |
| TabListener listener = new TabListener() { |
| public boolean onBeforeTabSelected(SourcesTabEvents sender, int tabIndex) { |
| beforeSelection = tabIndex; |
| if (tabIndex == 1) { |
| return false; |
| } else { |
| return true; |
| } |
| } |
| |
| public void onTabSelected(SourcesTabEvents sender, int tabIndex) { |
| selected = tabIndex; |
| } |
| }; |
| bar.addTabListener(listener); |
| boolean result = bar.selectTab(-1); |
| assertEquals(-1, beforeSelection); |
| assertEquals(0, selected); |
| assertTrue(result); |
| |
| result = bar.selectTab(1); |
| assertFalse(result); |
| assertEquals(0, selected); |
| assertEquals(1, beforeSelection); |
| |
| result = bar.selectTab(2); |
| assertTrue(result); |
| assertEquals(2, selected); |
| assertEquals(2, beforeSelection); |
| } |
| |
| public void testSelectionEvents() { |
| TabBar bar = new TabBar(); |
| RootPanel.get().add(bar); |
| |
| bar.addTab("foo"); |
| bar.addTab("bar"); |
| |
| // Make sure selecting a tab fires both events in the right order. |
| TestSelectionHandler handler = new TestSelectionHandler(); |
| bar.addBeforeSelectionHandler(handler); |
| bar.addSelectionHandler(handler); |
| bar.selectTab(1); |
| handler.assertOnBeforeSelectionFired(true); |
| handler.assertOnSelectionFired(true); |
| } |
| |
| public void testSelectionEventsNoFire() { |
| TabBar bar = new TabBar(); |
| RootPanel.get().add(bar); |
| |
| bar.addTab("foo"); |
| bar.addTab("bar"); |
| |
| TestSelectionHandler handler = new TestSelectionHandler(); |
| bar.addBeforeSelectionHandler(handler); |
| bar.addSelectionHandler(handler); |
| bar.selectTab(1, false); |
| handler.assertOnBeforeSelectionFired(false); |
| handler.assertOnSelectionFired(false); |
| } |
| |
| public void testSetTabSafeHtml() { |
| TabBar bar = createTabBar(); |
| bar.insertTab("foo", 0); |
| bar.setTabHTML(0, SafeHtmlUtils.fromSafeConstant(html)); |
| |
| assertEquals(html, bar.getTabHTML(0).toLowerCase()); |
| } |
| |
| public void testGetHTML() { |
| final TabBar bar = createTabBar(); |
| bar.addTab("foo"); |
| bar.addTab("<b>bar</b>", true); |
| bar.addTab("baz"); |
| assertEquals("foo", bar.getTabHTML(0)); |
| assertTrue("<b>bar</b>".equalsIgnoreCase(bar.getTabHTML(1))); |
| bar.removeTab(1); |
| assertEquals("baz", bar.getTabHTML(1)); |
| } |
| |
| public void testSetTextAndHTML() { |
| final TabBar bar = createTabBar(); |
| bar.addTab("foo"); |
| bar.addTab("bar"); |
| bar.addTab("baz"); |
| bar.addTab(new Grid(0, 0)); |
| |
| bar.setTabText(1, "w00t"); |
| assertEquals("w00t", bar.getTabHTML(1)); |
| |
| // toLowerCase() is necessary in these assertions because IE capitalizes |
| // HTML tags read from innerHTML. |
| bar.setTabHTML(1, "<i>w00t!</i>"); |
| assertEquals("<i>w00t!</i>", bar.getTabHTML(1).toLowerCase()); |
| |
| // Set the text knowing that we currently have an HTML. This should replace |
| // the HTML with a Label. |
| bar.setTabText(1, "<b>w00t</b>"); |
| assertEquals("<b>w00t</b>", bar.getTabHTML(1).toLowerCase()); |
| |
| // Set the text knowing that we currently have a Grid. This should replace |
| // the Grid with a Label. |
| bar.setTabText(3, "w00t"); |
| assertEquals("w00t", bar.getTabHTML(3)); |
| } |
| |
| /** |
| * Verify that if a tab contains a widget, {@link TabBar#getTabHTML(int)} |
| * returns the HTML of the focusable element with the widget inside of it. |
| */ |
| public void testGetHTMLWithWidget() { |
| TabBar bar = createTabBar(); |
| Button myButton = new Button("My Button"); |
| bar.addTab(myButton); |
| |
| Widget focusablePanel = myButton.getParent(); |
| assertEquals(focusablePanel.getElement().getParentElement().getInnerHTML(), |
| bar.getTabHTML(0)); |
| } |
| |
| /** |
| * Verify that wordWrap works when adding widgets that implement HasWordWrap. |
| */ |
| public void testWordWrapWithSupport() { |
| TabBar bar = createTabBar(); |
| Label tabContent0 = new Label("Tab 0", false); |
| Label tabContent1 = new Label("Tab 1", true); |
| bar.addTab(tabContent0); |
| bar.addTab(tabContent1); |
| bar.addTab("Tab 2"); |
| |
| // hasWordWrap() |
| { |
| assertTrue(bar.getTab(0).hasWordWrap()); |
| assertTrue(bar.getTab(1).hasWordWrap()); |
| assertTrue(bar.getTab(2).hasWordWrap()); |
| } |
| |
| // getWordWrap() |
| { |
| assertFalse(bar.getTab(0).getWordWrap()); |
| assertTrue(bar.getTab(1).getWordWrap()); |
| assertFalse(bar.getTab(2).getWordWrap()); |
| } |
| |
| // setWordWrap() |
| { |
| bar.getTab(0).setWordWrap(true); |
| bar.getTab(1).setWordWrap(true); |
| bar.getTab(2).setWordWrap(true); |
| assertTrue(bar.getTab(0).getWordWrap()); |
| assertTrue(bar.getTab(1).getWordWrap()); |
| assertTrue(bar.getTab(2).getWordWrap()); |
| assertTrue(tabContent0.getWordWrap()); |
| } |
| } |
| |
| /** |
| * Verify that wordWrap works when adding widgets that do not implement |
| * HasWordWrap. |
| */ |
| public void testWordWrapWithoutSupport() { |
| TabBar bar = createTabBar(); |
| bar.addTab(new Button("Tab 0")); |
| |
| // hasWordWrap |
| assertFalse(bar.getTab(0).hasWordWrap()); |
| |
| // getWordWrap(); |
| try { |
| bar.getTab(0).getWordWrap(); |
| fail("Expected UnsupportedOperationException"); |
| } catch (UnsupportedOperationException e) { |
| assertTrue(true); |
| } |
| |
| // setWordWrap(); |
| try { |
| bar.getTab(0).setWordWrap(true); |
| fail("Expected UnsupportedOperationException"); |
| } catch (UnsupportedOperationException e) { |
| assertTrue(true); |
| } |
| } |
| |
| /** |
| * Create a new, empty tab bar. |
| */ |
| protected TabBar createTabBar() { |
| return new TabBar(); |
| } |
| } |