001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: /**
018: * @author Pavel Dolgov
019: * @version $Revision$
020: */package java.awt.dnd;
021:
022: import java.awt.Component;
023: import java.awt.Frame;
024: import java.awt.Point;
025: import java.awt.datatransfer.DataFlavor;
026: import java.awt.datatransfer.FlavorMap;
027: import java.awt.datatransfer.SystemFlavorMap;
028: import java.awt.peer.ComponentPeer;
029: import java.util.HashMap;
030: import java.util.Map;
031: import java.util.TooManyListenersException;
032:
033: import junit.framework.TestCase;
034:
035: /**
036: * Unit test for class java.awt.dnd.DropTarget
037: */
038: @SuppressWarnings("serial")
039: public class DropTargetTest extends TestCase {
040:
041: static class DTL implements DropTargetListener {
042:
043: public boolean exited;
044: public boolean dropped;
045: public boolean changed;
046: public boolean hovered;
047: public boolean entered;
048:
049: public void dragExit(DropTargetEvent dte) {
050: exited = true;
051: }
052:
053: public void drop(DropTargetDropEvent dtde) {
054: dropped = true;
055: }
056:
057: public void dropActionChanged(DropTargetDragEvent dtde) {
058: changed = true;
059: }
060:
061: public void dragOver(DropTargetDragEvent dtde) {
062: hovered = true;
063: }
064:
065: public void dragEnter(DropTargetDragEvent dtde) {
066: entered = true;
067: }
068: }
069:
070: static class FM implements FlavorMap {
071: public Map<String, DataFlavor> getFlavorsForNatives(
072: String[] natives) {
073: return new HashMap<String, DataFlavor>();
074: }
075:
076: public Map<DataFlavor, String> getNativesForFlavors(
077: DataFlavor[] flavors) {
078: return new HashMap<DataFlavor, String>();
079: }
080: }
081:
082: static class AddRemoveDropTarget extends DropTarget {
083: public boolean added;
084: public boolean removed;
085:
086: public AddRemoveDropTarget(Component c) {
087: super (c, null);
088: }
089:
090: @Override
091: public void addNotify(ComponentPeer peer) {
092: added = true;
093: super .addNotify(peer);
094: }
095:
096: @Override
097: public void removeNotify(ComponentPeer peer) {
098: removed = true;
099: super .removeNotify(peer);
100: }
101: }
102:
103: public static void main(String[] args) {
104: junit.textui.TestRunner.run(DropTargetTest.class);
105: }
106:
107: @Override
108: protected void setUp() throws Exception {
109: super .setUp();
110: }
111:
112: public void testDropTargetComponentintDropTargetListenerbooleanFlavorMap() {
113: Component c = new Component() {
114: };
115: int ops = 1;
116: DropTargetListener dtl = new DTL();
117: FlavorMap fm = new FM();
118: DropTarget dt = new DropTarget(c, ops, dtl, false, fm);
119: assertSame(c, dt.getComponent());
120: assertSame(dt, c.getDropTarget());
121: assertEquals(ops, dt.getDefaultActions());
122: assertFalse(dt.isActive());
123: assertSame(fm, dt.getFlavorMap());
124: try {
125: dt.removeDropTargetListener(new DTL());
126: fail("IllegalArgumentException expected");
127: } catch (IllegalArgumentException e) {
128: }
129: dt.removeDropTargetListener(dtl);
130: }
131:
132: public void testDropTargetComponentDropTargetListener() {
133: }
134:
135: public void testDropTargetComponentintDropTargetListenerboolean() {
136: }
137:
138: public void testDropTargetComponentintDropTargetListener() {
139: }
140:
141: public void testDropTarget() {
142: DropTarget dt = new DropTarget();
143: assertNull(dt.getComponent());
144: assertEquals(DnDConstants.ACTION_COPY_OR_MOVE, dt
145: .getDefaultActions());
146: assertSame(SystemFlavorMap.getDefaultFlavorMap(), dt
147: .getFlavorMap());
148: assertTrue(dt.isActive());
149: }
150:
151: public void testCreateDropTargetAutoScroller() {
152: final Component comp = new Component() {
153: };
154: final Point start = new Point(10, 10);
155: DropTarget dt = new DropTarget(comp, new DTL()) {
156: @Override
157: protected DropTargetAutoScroller createDropTargetAutoScroller(
158: Component c, Point p) {
159: assertSame(comp, c);
160: assertSame(start, p);
161: DropTargetAutoScroller ret = super
162: .createDropTargetAutoScroller(c, p);
163: assertNotNull(ret);
164: return ret;
165: }
166: };
167: dt.initializeAutoscrolling(start);
168: }
169:
170: public void testRemoveNotify() {
171: }
172:
173: public void testAddNotify() {
174: // Regression for HARMONY-2492
175: new DropTarget().addNotify(null);
176: }
177:
178: public void testAddRemoveNotify() {
179: Frame f = new Frame("DropTargetTest");
180: Component c = new Component() {
181: };
182: AddRemoveDropTarget dt = new AddRemoveDropTarget(c);
183: f.add(c);
184: assertFalse(dt.added);
185: f.addNotify();
186: assertTrue(dt.added);
187: assertFalse(dt.removed);
188: f.dispose();
189: assertTrue(dt.removed);
190: }
191:
192: public void testRemoveDropTargetListener()
193: throws TooManyListenersException {
194: DropTarget dt = new DropTarget();
195: DropTargetListener dtl = new DTL();
196: dt.removeDropTargetListener(null);
197: dt.removeDropTargetListener(new DTL());
198: dt.addDropTargetListener(dtl);
199: dt.removeDropTargetListener(null);
200: try {
201: dt.removeDropTargetListener(new DTL());
202: fail("IllegalArgumentException expected");
203: } catch (IllegalArgumentException e) {
204: }
205: dt.removeDropTargetListener(dtl);
206: try {
207: dt.addDropTargetListener(new DTL());
208: } catch (TooManyListenersException e) {
209: fail("Listener wasn't removed");
210: }
211: }
212:
213: public void testAddDropTargetListener() {
214: DropTarget dt = new DropTarget();
215: DropTargetListener dtl = new DTL();
216:
217: try {
218: dt.addDropTargetListener(null);
219: } catch (TooManyListenersException e) {
220: fail("Null listener should be ignored");
221: }
222: try {
223: dt.addDropTargetListener(dt);
224: fail("IllegalArgumentException expected");
225: } catch (IllegalArgumentException e) {
226: } catch (TooManyListenersException e) {
227: fail("Adding this listener should cause IllegalArgumentException");
228: }
229: try {
230: dt.addDropTargetListener(dtl);
231: } catch (TooManyListenersException e) {
232: fail("TooManyListenersException " + e.getMessage());
233: }
234: try {
235: dt.addDropTargetListener(null);
236: } catch (TooManyListenersException e) {
237: fail("Null listener should be ignored");
238: }
239: try {
240: dt.addDropTargetListener(dtl);
241: fail("TooManyListenersException expected");
242: } catch (TooManyListenersException e) {
243: }
244: try {
245: dt.addDropTargetListener(new DTL());
246: fail("TooManyListenersException expected");
247: } catch (TooManyListenersException e) {
248: }
249: }
250:
251: public void testDragExit() {
252: DropTarget dt = new DropTarget();
253: DropTargetEvent dte = new DropTargetEvent(dt
254: .getDropTargetContext());
255: dt.dragExit(dte);
256: DTL dtl = new DTL();
257: try {
258: dt.addDropTargetListener(dtl);
259: } catch (TooManyListenersException e) {
260: fail("TooManyListenersException");
261: }
262: dt.dragExit(null);
263: dt.dragExit(dte);
264: assertTrue(dtl.exited);
265: dtl.exited = false;
266: dt.setActive(false);
267: dt.dragExit(dte);
268: assertFalse(dtl.exited);
269: dt.removeDropTargetListener(dtl);
270: dt.dragExit(dte);
271: assertFalse(dtl.exited);
272: dt.dragExit(null);
273: }
274:
275: public void testDrop() {
276: DropTarget dt = new DropTarget();
277: DropTargetDropEvent dtde = new DropTargetDropEvent(dt
278: .getDropTargetContext(), new Point(0, 0),
279: DnDConstants.ACTION_COPY, DnDConstants.ACTION_COPY);
280: dt.drop(dtde);
281: DTL dtl = new DTL();
282: try {
283: dt.addDropTargetListener(dtl);
284: } catch (TooManyListenersException e) {
285: fail("TooManyListenersException");
286: }
287: dt.drop(null);
288: dt.drop(dtde);
289: assertTrue(dtl.dropped);
290: dtl.dropped = false;
291: dt.setActive(false);
292: dt.drop(dtde);
293: assertFalse(dtl.dropped);
294: dt.removeDropTargetListener(dtl);
295: dt.drop(dtde);
296: assertFalse(dtl.dropped);
297: try {
298: dt.drop(null);
299: fail("NullPointerException expected");
300: } catch (NullPointerException e) {
301: }
302: }
303:
304: public void testDropActionChanged() {
305: DropTarget dt = new DropTarget();
306: DropTargetDragEvent dtde = new DropTargetDragEvent(dt
307: .getDropTargetContext(), new Point(0, 0),
308: DnDConstants.ACTION_COPY, DnDConstants.ACTION_COPY);
309: dt.dropActionChanged(dtde);
310: DTL dtl = new DTL();
311: try {
312: dt.addDropTargetListener(dtl);
313: } catch (TooManyListenersException e) {
314: fail("TooManyListenersException");
315: }
316: try {
317: dt.dropActionChanged(null);
318: fail("NullPointerException expected");
319: } catch (NullPointerException e) {
320: }
321: dt.dropActionChanged(dtde);
322: assertTrue(dtl.changed);
323: dtl.changed = false;
324: dt.setActive(false);
325: dt.dropActionChanged(dtde);
326: assertFalse(dtl.changed);
327: dt.removeDropTargetListener(dtl);
328: dt.dropActionChanged(dtde);
329: assertFalse(dtl.changed);
330: dt.dropActionChanged(null);
331: }
332:
333: public void testDragOver() {
334: DropTarget dt = new DropTarget();
335: DropTargetDragEvent dtde = new DropTargetDragEvent(dt
336: .getDropTargetContext(), new Point(0, 0),
337: DnDConstants.ACTION_COPY, DnDConstants.ACTION_COPY);
338: dt.dragOver(dtde);
339: DTL dtl = new DTL();
340: try {
341: dt.addDropTargetListener(dtl);
342: } catch (TooManyListenersException e) {
343: fail("TooManyListenersException");
344: }
345: try {
346: dt.dragOver(null);
347: fail("NullPointerException expected");
348: } catch (NullPointerException e) {
349: }
350: dt.dragOver(dtde);
351: assertTrue(dtl.hovered);
352: dtl.hovered = false;
353: dt.setActive(false);
354: dt.dragOver(dtde);
355: assertFalse(dtl.hovered);
356: dt.removeDropTargetListener(dtl);
357: dt.dragOver(dtde);
358: assertFalse(dtl.hovered);
359: dt.dragOver(null);
360: }
361:
362: public void testDragEnter() {
363: DropTarget dt = new DropTarget();
364: DropTargetDragEvent dtde = new DropTargetDragEvent(dt
365: .getDropTargetContext(), new Point(0, 0),
366: DnDConstants.ACTION_COPY, DnDConstants.ACTION_COPY);
367: dt.dragEnter(dtde);
368: DTL dtl = new DTL();
369: try {
370: dt.addDropTargetListener(dtl);
371: } catch (TooManyListenersException e) {
372: fail("TooManyListenersException");
373: }
374: try {
375: dt.dragEnter(null);
376: fail("NullPointerException expected");
377: } catch (NullPointerException e) {
378: }
379: dt.dragEnter(dtde);
380: assertTrue(dtl.entered);
381: dtl.entered = false;
382: dt.setActive(false);
383: dt.dragEnter(dtde);
384: assertFalse(dtl.entered);
385: dt.removeDropTargetListener(dtl);
386: dt.dragEnter(dtde);
387: assertFalse(dtl.entered);
388: dt.dragEnter(null);
389: }
390:
391: public void testGetDropTargetContext() {
392: Component c = new Component() {
393: };
394: int ops = 1;
395: DropTargetListener dtl = new DTL();
396: FlavorMap fm = new FM();
397: DropTarget dt = new DropTarget(c, ops, dtl, false, fm);
398: DropTargetContext dtc = dt.getDropTargetContext();
399: assertSame(c, dtc.getComponent());
400: assertSame(dt, dtc.getDropTarget());
401: }
402:
403: public void testCreateDropTargetContext() {
404: }
405:
406: public void testSetFlavorMap() {
407: DropTarget dt = new DropTarget();
408: assertSame(SystemFlavorMap.getDefaultFlavorMap(), dt
409: .getFlavorMap());
410: FlavorMap fm = new FM();
411: dt.setFlavorMap(fm);
412: assertSame(fm, dt.getFlavorMap());
413: dt.setFlavorMap(null);
414: assertSame(SystemFlavorMap.getDefaultFlavorMap(), dt
415: .getFlavorMap());
416: }
417:
418: public void testGetFlavorMap() {
419: FlavorMap fm = new FM();
420: DropTarget dt = new DropTarget(null, 1, null, false, fm);
421: assertSame(fm, dt.getFlavorMap());
422: dt = new DropTarget();
423: assertSame(SystemFlavorMap.getDefaultFlavorMap(), dt
424: .getFlavorMap());
425: }
426:
427: public void testUpdateAutoscroll() {
428: }
429:
430: public void testInitializeAutoscrolling() {
431: }
432:
433: public void testSetComponent() {
434: DropTarget dt = new DropTarget();
435: Component c = new Component() {
436: };
437: assertNull(dt.getComponent());
438: dt.setComponent(c);
439: assertSame(c, dt.getComponent());
440: assertSame(dt, c.getDropTarget());
441: dt.setComponent(null);
442: assertNull(dt.getComponent());
443: assertNull(c.getDropTarget());
444: }
445:
446: public void testGetComponent() {
447: DropTarget dt = new DropTarget();
448: Component c = new Component() {
449: };
450: assertNull(dt.getComponent());
451: dt = new DropTarget(c, null);
452: assertSame(c, dt.getComponent());
453: }
454:
455: public void testSetActive() {
456: DropTarget dt = new DropTarget(null, 1, null, true);
457: assertTrue(dt.isActive());
458: dt.setActive(false);
459: assertFalse(dt.isActive());
460: dt.setActive(true);
461: assertTrue(dt.isActive());
462: }
463:
464: public void testSetDefaultActions() {
465: DropTarget dt = new DropTarget();
466: testCheckDefaultAction(dt, DnDConstants.ACTION_NONE);
467: testCheckDefaultAction(dt, DnDConstants.ACTION_COPY);
468: testCheckDefaultAction(dt, DnDConstants.ACTION_COPY_OR_MOVE);
469: testCheckDefaultAction(dt, DnDConstants.ACTION_LINK);
470: testCheckDefaultAction(dt, DnDConstants.ACTION_MOVE);
471: testCheckDefaultAction(dt, DnDConstants.ACTION_REFERENCE);
472: testCheckDefaultAction(dt, 0xFF,
473: DnDConstants.ACTION_COPY_OR_MOVE);
474: testCheckDefaultAction(dt, DnDConstants.ACTION_LINK
475: | DnDConstants.ACTION_COPY_OR_MOVE);
476: testCheckDefaultAction(dt, DnDConstants.ACTION_LINK
477: | ~DnDConstants.ACTION_COPY_OR_MOVE,
478: DnDConstants.ACTION_LINK);
479: testCheckDefaultAction(dt, DnDConstants.ACTION_COPY_OR_MOVE
480: | ~DnDConstants.ACTION_LINK,
481: DnDConstants.ACTION_COPY_OR_MOVE);
482: }
483:
484: private void testCheckDefaultAction(DropTarget dt, int ops) {
485: testCheckDefaultAction(dt, ops, ops);
486: }
487:
488: private void testCheckDefaultAction(DropTarget dt, int ops,
489: int expected) {
490: dt.setDefaultActions(ops);
491: assertEquals(expected, dt.getDefaultActions());
492: }
493:
494: public void testIsActive() {
495: Component c = new Component() {
496: };
497: DropTarget dt = new DropTarget(c, 1, null, true);
498: assertTrue(dt.isActive());
499: dt = new DropTarget(c, 1, null, false);
500: assertFalse(dt.isActive());
501:
502: dt = new DropTarget(null, 1, null, false);
503: assertTrue(dt.isActive());
504: dt.setComponent(c);
505: assertTrue(dt.isActive());
506: }
507:
508: public void testClearAutoscroll() {
509: }
510:
511: public void testGetDefaultActions() {
512: checkGetDefaultActions(DnDConstants.ACTION_NONE);
513: checkGetDefaultActions(DnDConstants.ACTION_COPY);
514: checkGetDefaultActions(DnDConstants.ACTION_COPY_OR_MOVE);
515: checkGetDefaultActions(DnDConstants.ACTION_LINK);
516: checkGetDefaultActions(DnDConstants.ACTION_MOVE);
517: checkGetDefaultActions(DnDConstants.ACTION_REFERENCE);
518: }
519:
520: private void checkGetDefaultActions(int ops) {
521: DropTarget dt = new DropTarget(null, ops, null);
522: assertEquals(ops, dt.getDefaultActions());
523: }
524:
525: public void testSetDropTarget() {
526: Component c = new Component() {
527: };
528: DropTarget dt = new DropTarget();
529: c.setDropTarget(dt);
530: assertSame(dt, c.getDropTarget());
531: assertSame(c, dt.getComponent());
532:
533: DropTarget dt2 = new DropTarget();
534: c.setDropTarget(dt2);
535: assertSame(dt2, c.getDropTarget());
536: assertSame(c, dt2.getComponent());
537: assertNull(dt.getComponent());
538:
539: c.setDropTarget(null);
540: assertNull(c.getDropTarget());
541: assertNull(dt.getComponent());
542: }
543: }
|