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: package org.apache.harmony.luni.tests.java.util;
019:
020: import java.util.Observable;
021: import java.util.Observer;
022: import java.util.Vector;
023:
024: public class ObservableTest extends junit.framework.TestCase {
025:
026: static class TestObserver implements Observer {
027: public Vector objv = new Vector();
028:
029: int updateCount = 0;
030:
031: public void update(Observable observed, Object arg) {
032: ++updateCount;
033: objv.add(arg);
034: }
035:
036: public int updateCount() {
037: return updateCount;
038: }
039:
040: }
041:
042: static class DeleteTestObserver implements Observer {
043: int updateCount = 0;
044:
045: boolean deleteAll = false;
046:
047: public DeleteTestObserver(boolean all) {
048: deleteAll = all;
049: }
050:
051: public void update(Observable observed, Object arg) {
052: ++updateCount;
053: if (deleteAll)
054: observed.deleteObservers();
055: else
056: observed.deleteObserver(this );
057: }
058:
059: public int updateCount() {
060: return updateCount;
061: }
062:
063: }
064:
065: static class TestObservable extends Observable {
066: public void doChange() {
067: setChanged();
068: }
069: }
070:
071: Observer observer;
072:
073: TestObservable observable;
074:
075: /**
076: * @tests java.util.Observable#Observable()
077: */
078: public void test_Constructor() {
079: // Test for method java.util.Observable()
080: Observable ov = new Observable();
081: assertTrue("Wrong initial values.", !ov.hasChanged());
082: assertEquals("Wrong initial values.", 0, ov.countObservers());
083: }
084:
085: /**
086: * @tests java.util.Observable#addObserver(java.util.Observer)
087: */
088: public void test_addObserverLjava_util_Observer() {
089: // Test for method void
090: // java.util.Observable.addObserver(java.util.Observer)
091: TestObserver test = new TestObserver();
092: observable.addObserver(test);
093: assertEquals("Failed to add observer", 1, observable
094: .countObservers());
095: observable.addObserver(test);
096: assertEquals("Duplicate observer", 1, observable
097: .countObservers());
098:
099: Observable o = new Observable();
100: try {
101: o.addObserver(null);
102: fail("Expected adding a null observer to throw a NPE.");
103: } catch (NullPointerException ex) {
104: // expected;
105: }
106: }
107:
108: /**
109: * @tests java.util.Observable#countObservers()
110: */
111: public void test_countObservers() {
112: // Test for method int java.util.Observable.countObservers()
113: assertEquals("New observable had > 0 observers", 0, observable
114: .countObservers());
115: observable.addObserver(new TestObserver());
116: assertEquals("Observable with observer returned other than 1",
117: 1, observable.countObservers());
118: }
119:
120: /**
121: * @tests java.util.Observable#deleteObserver(java.util.Observer)
122: */
123: public void test_deleteObserverLjava_util_Observer() {
124: // Test for method void
125: // java.util.Observable.deleteObserver(java.util.Observer)
126: observable.addObserver(observer = new TestObserver());
127: observable.deleteObserver(observer);
128: assertEquals("Failed to delete observer", 0, observable
129: .countObservers());
130:
131: }
132:
133: /**
134: * @tests java.util.Observable#deleteObservers()
135: */
136: public void test_deleteObservers() {
137: // Test for method void java.util.Observable.deleteObservers()
138: observable.addObserver(new TestObserver());
139: observable.addObserver(new TestObserver());
140: observable.addObserver(new TestObserver());
141: observable.addObserver(new TestObserver());
142: observable.addObserver(new TestObserver());
143: observable.addObserver(new TestObserver());
144: observable.addObserver(new TestObserver());
145: observable.addObserver(new TestObserver());
146: observable.deleteObservers();
147: assertEquals("Failed to delete observers", 0, observable
148: .countObservers());
149: }
150:
151: /**
152: * @tests java.util.Observable#hasChanged()
153: */
154: public void test_hasChanged() {
155: // TODO : Implement test
156: }
157:
158: /**
159: * @tests java.util.Observable#notifyObservers()
160: */
161: public void test_notifyObservers() {
162: // Test for method void java.util.Observable.notifyObservers()
163: observable.addObserver(observer = new TestObserver());
164: observable.notifyObservers();
165: assertEquals("Notified when unchnaged", 0,
166: ((TestObserver) observer).updateCount());
167: ((TestObservable) observable).doChange();
168: observable.notifyObservers();
169: assertEquals("Failed to notify", 1, ((TestObserver) observer)
170: .updateCount());
171:
172: DeleteTestObserver observer1, observer2;
173: observable.deleteObservers();
174: observable
175: .addObserver(observer1 = new DeleteTestObserver(false));
176: observable
177: .addObserver(observer2 = new DeleteTestObserver(false));
178: observable.doChange();
179: observable.notifyObservers();
180: assertTrue("Failed to notify all", observer1.updateCount() == 1
181: && observer2.updateCount() == 1);
182: assertEquals("Failed to delete all", 0, observable
183: .countObservers());
184:
185: observable
186: .addObserver(observer1 = new DeleteTestObserver(false));
187: observable
188: .addObserver(observer2 = new DeleteTestObserver(false));
189: observable.doChange();
190: observable.notifyObservers();
191: assertTrue("Failed to notify all 2",
192: observer1.updateCount() == 1
193: && observer2.updateCount() == 1);
194: assertEquals("Failed to delete all 2", 0, observable
195: .countObservers());
196: }
197:
198: /**
199: * @tests java.util.Observable#notifyObservers(java.lang.Object)
200: */
201: public void test_notifyObserversLjava_lang_Object() {
202: // Test for method void
203: // java.util.Observable.notifyObservers(java.lang.Object)
204: Object obj;
205: observable.addObserver(observer = new TestObserver());
206: observable.notifyObservers();
207: assertEquals("Notified when unchanged", 0,
208: ((TestObserver) observer).updateCount());
209: ((TestObservable) observable).doChange();
210: observable.notifyObservers(obj = new Object());
211: assertEquals("Failed to notify", 1, ((TestObserver) observer)
212: .updateCount());
213: assertTrue("Failed to pass Object arg",
214: ((TestObserver) observer).objv.elementAt(0).equals(obj));
215: }
216:
217: /**
218: * Sets up the fixture, for example, open a network connection. This method
219: * is called before a test is executed.
220: */
221: protected void setUp() {
222: observable = new TestObservable();
223: }
224:
225: /**
226: * Tears down the fixture, for example, close a network connection. This
227: * method is called after a test is executed.
228: */
229: protected void tearDown() {
230: }
231: }
|