← Back to branch summary

~ubuntu-branches/ubuntu/utopic/eclipse-linuxtools/utopic

« back to all changes in this revision

Viewing changes to lttng/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/signal/TmfSignalThrottlerTest.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2014-05-12 18:11:40 UTC
  • mfrom: (3.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140512181140-w237r3vsah1tmybz
Tags: 2.2.1-1
* New upstream release.
* Refreshed d/patches.
* Removed eclipse-cdt-valgrind-remote package, all its functionality
  is now provided by eclipse-cdt-profiling-framework-remote.
* Added remove-license-feature.patch.
* Bump Standards-Version to 3.9.5.
* Enable eclipse-changelog package.
* Enable eclipse-rpm-editor package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lttng/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/signal/TmfSignalThrottlerTest.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2013 Ericsson
 
3
 *
 
4
 * All rights reserved. This program and the accompanying materials are
 
5
 * made available under the terms of the Eclipse Public License v1.0 which
 
6
 * accompanies this distribution, and is available at
 
7
 * http://www.eclipse.org/legal/epl-v10.html
 
8
 *
 
9
 * Contributors:
 
10
 *   Alexandre Montplaisir - Initial API and implementation
 
11
 *******************************************************************************/
 
12
 
 
13
package org.eclipse.linuxtools.tmf.core.tests.signal;
 
14
 
 
15
import static org.junit.Assert.assertEquals;
 
16
 
 
17
import java.util.ArrayList;
 
18
import java.util.Collections;
 
19
import java.util.List;
 
20
 
 
21
import org.eclipse.linuxtools.tmf.core.component.TmfComponent;
 
22
import org.eclipse.linuxtools.tmf.core.signal.TmfSignal;
 
23
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
 
24
import org.eclipse.linuxtools.tmf.core.signal.TmfSignalThrottler;
 
25
import org.junit.After;
 
26
import org.junit.Before;
 
27
import org.junit.Test;
 
28
 
 
29
/**
 
30
 * Test suite for {@link TmfSignalThrottler}
 
31
 *
 
32
 * @author Alexandre Montplaisir
 
33
 */
 
34
public class TmfSignalThrottlerTest {
 
35
 
 
36
    private MySender sender;
 
37
    private MyListener listener;
 
38
 
 
39
    /**
 
40
     * Pre-test setup
 
41
     */
 
42
    @Before
 
43
    public void setUp() {
 
44
        sender = new MySender();
 
45
        listener = new MyListener();
 
46
    }
 
47
 
 
48
    /**
 
49
     * After-test cleanup
 
50
     */
 
51
    @After
 
52
    public void tearDown() {
 
53
        sender.dispose();
 
54
        listener.dispose();
 
55
    }
 
56
 
 
57
    // ------------------------------------------------------------------------
 
58
    // Test cases
 
59
    // ------------------------------------------------------------------------
 
60
 
 
61
    /**
 
62
     * Test using only one throttler. Only one signal should go through.
 
63
     */
 
64
    @Test
 
65
    public void testOneChannel() {
 
66
        final MySignal sig1 = new MySignal(sender, 0);
 
67
        final MySignal sig2 = new MySignal(sender, 0);
 
68
        final MySignal sig3 = new MySignal(sender, 0);
 
69
 
 
70
        synchronized(this) {
 
71
            sender.sendSignal(sig1);
 
72
            sender.sendSignal(sig2);
 
73
            sender.sendSignal(sig3);
 
74
        }
 
75
 
 
76
        sleep(1000);
 
77
 
 
78
        assertEquals(1, listener.nbReceived[0]);
 
79
        assertEquals(0, listener.nbReceived[1]);
 
80
        assertEquals(0, listener.nbReceived[2]);
 
81
    }
 
82
 
 
83
    /**
 
84
     * Test using multiple throttlers in parrallel. Only one signal per
 
85
     * throttler should go through.
 
86
     */
 
87
    @Test
 
88
    public void testMultipleChannels() {
 
89
        List<MySignal> signals = new ArrayList<MySignal>();
 
90
        signals.add(new MySignal(sender, 0));
 
91
        signals.add(new MySignal(sender, 0));
 
92
        signals.add(new MySignal(sender, 0));
 
93
 
 
94
        signals.add(new MySignal(sender, 1));
 
95
        signals.add(new MySignal(sender, 1));
 
96
        signals.add(new MySignal(sender, 1));
 
97
 
 
98
        signals.add(new MySignal(sender, 2));
 
99
        signals.add(new MySignal(sender, 2));
 
100
        signals.add(new MySignal(sender, 2));
 
101
 
 
102
        Collections.shuffle(signals); /* Every day */
 
103
 
 
104
        synchronized(this) {
 
105
            for (MySignal sig : signals) {
 
106
                sender.sendSignal(sig);
 
107
            }
 
108
        }
 
109
 
 
110
        sleep(2000);
 
111
 
 
112
        for (int nb : listener.nbReceived) {
 
113
            assertEquals(1, nb);
 
114
        }
 
115
    }
 
116
 
 
117
    /**
 
118
     * Test with one throttler, sending signals slowly. All three signals should
 
119
     * go through.
 
120
     */
 
121
    @Test
 
122
    public void testDelay() {
 
123
        final MySignal sig1 = new MySignal(sender, 0);
 
124
        final MySignal sig2 = new MySignal(sender, 0);
 
125
        final MySignal sig3 = new MySignal(sender, 0);
 
126
 
 
127
        sender.sendSignal(sig1);
 
128
        sleep(1000);
 
129
        sender.sendSignal(sig2);
 
130
        sleep(1000);
 
131
        sender.sendSignal(sig3);
 
132
        sleep(1000);
 
133
 
 
134
        assertEquals(3, listener.nbReceived[0]);
 
135
    }
 
136
 
 
137
    // ------------------------------------------------------------------------
 
138
    // Helper methods
 
139
    // ------------------------------------------------------------------------
 
140
 
 
141
    private static void sleep(long millis) {
 
142
        try {
 
143
            Thread.sleep(millis);
 
144
        } catch (InterruptedException e) {
 
145
            e.printStackTrace();
 
146
        }
 
147
    }
 
148
 
 
149
    // ------------------------------------------------------------------------
 
150
    // Helper classes
 
151
    // ------------------------------------------------------------------------
 
152
 
 
153
    /**
 
154
     * Signal sender
 
155
     */
 
156
    private class MySender extends TmfComponent {
 
157
 
 
158
        private final TmfSignalThrottler[] throttlers;
 
159
 
 
160
        MySender() {
 
161
            super("MySender");
 
162
            throttlers = new TmfSignalThrottler[] {
 
163
                    new TmfSignalThrottler(this,  200),
 
164
                    new TmfSignalThrottler(this,  500),
 
165
                    new TmfSignalThrottler(this, 1000),
 
166
            };
 
167
        }
 
168
 
 
169
        void sendSignal(MySignal signal) {
 
170
            throttlers[signal.getChannel()].queue(signal);
 
171
        }
 
172
 
 
173
        @Override
 
174
        public void dispose() {
 
175
            super.dispose();
 
176
            for (TmfSignalThrottler elem : throttlers) {
 
177
                elem.dispose();
 
178
            }
 
179
        }
 
180
    }
 
181
 
 
182
    /**
 
183
     * Signal listener
 
184
     */
 
185
    public class MyListener extends TmfComponent {
 
186
 
 
187
        int[] nbReceived = { 0, 0, 0 };
 
188
 
 
189
        /**
 
190
         * Constructor. Needs to be public so TmfSignalHandler can see it.
 
191
         */
 
192
        public MyListener() {
 
193
            super("MyListener");
 
194
        }
 
195
 
 
196
        /**
 
197
         * Receive a signal.
 
198
         *
 
199
         * @param sig
 
200
         *            Signal received
 
201
         */
 
202
        @TmfSignalHandler
 
203
        public void receiveSignal(final MySignal sig) {
 
204
            nbReceived[sig.getChannel()]++;
 
205
        }
 
206
    }
 
207
 
 
208
    /**
 
209
     * Signal object
 
210
     */
 
211
    private class MySignal extends TmfSignal {
 
212
 
 
213
        private final int channel;
 
214
 
 
215
        public MySignal(MySender source, int channel) {
 
216
            super(source);
 
217
            this.channel = channel;
 
218
        }
 
219
 
 
220
        public int getChannel() {
 
221
            return channel;
 
222
        }
 
223
    }
 
224
}