From 7a69132e9def0967c866baeeee31dfec157eb077 Mon Sep 17 00:00:00 2001 From: greatim Date: Wed, 4 Mar 2015 14:00:07 +0900 Subject: [PATCH] INTERNAL: refactor major thread class for unity create DataThread class for major thread like data channel thread, message parser, log parser, page data thread, db inserter. use offer() function instead put() function of blocking queue. Change-Id: Ic02b4d2368c63c5259d64b321f9ef295b354367f Signed-off-by: greatim --- .../widgets/helper/ImageResources.java | 1 - .../dynamicanalyzer/workbench/Application.java | 4 - .../org/tizen/dynamicanalyzer/common/Global.java | 1 + .../tizen/dynamicanalyzer/control/DataThread.java | 137 ++++++++++++++++++++ .../tizen/dynamicanalyzer/control/SideWorker.java | 8 +- .../dynamicanalyzer/control/StartTraceManager.java | 26 ++-- .../dynamicanalyzer/control/StopTraceManager.java | 6 +- .../tizen/dynamicanalyzer/database/DBInserter.java | 84 ++++--------- .../database/SqlConnectionManager.java | 30 ++--- .../dynamicanalyzer/handlers/ExitHandler.java | 6 - .../swap/communicator/Communicator30.java | 1 + .../swap/communicator/DataChannelThread.java | 105 ++++++---------- .../swap/logparser/DataManagerRegistry.java | 8 +- .../dynamicanalyzer/swap/logparser/LogParser.java | 116 +++++------------ .../swap/logparser/MessageParser.java | 139 ++++++--------------- .../swap/logparser/PageDataManager.java | 112 +++++------------ .../swap/model/data/ByteStreamData.java | 4 +- .../ui/timeline/chart/UserCustomChart.java | 1 - .../ui/toolbar/setting/data/FeatureDataTest.java | 2 +- .../setting/data/SettingDataManagerTest.java | 6 +- .../ui/toolbar/setting/data/TargetDataTest.java | 5 +- .../ui/toolbar/setting/data/TemplateDataTest.java | 3 +- 22 files changed, 354 insertions(+), 451 deletions(-) create mode 100644 org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/DataThread.java diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ImageResources.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ImageResources.java index f131112..31f4099 100644 --- a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ImageResources.java +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ImageResources.java @@ -34,7 +34,6 @@ import org.eclipse.jface.resource.ImageDescriptor; import org.eclipse.jface.resource.ImageRegistry; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; -import org.tizen.dynamicanalyzer.util.Logger; public class ImageResources { private static ImageRegistry imageRegistry = new ImageRegistry(); diff --git a/org.tizen.dynamicanalyzer.workbench/src/org/tizen/dynamicanalyzer/workbench/Application.java b/org.tizen.dynamicanalyzer.workbench/src/org/tizen/dynamicanalyzer/workbench/Application.java index 4ef02b7..558b902 100755 --- a/org.tizen.dynamicanalyzer.workbench/src/org/tizen/dynamicanalyzer/workbench/Application.java +++ b/org.tizen.dynamicanalyzer.workbench/src/org/tizen/dynamicanalyzer/workbench/Application.java @@ -29,11 +29,7 @@ package org.tizen.dynamicanalyzer.workbench; import java.io.BufferedReader; import java.io.File; -import java.io.FileOutputStream; import java.io.FileReader; -import java.io.IOException; -import java.io.OutputStream; -import java.io.PrintStream; import java.net.MalformedURLException; import java.net.URL; import java.text.SimpleDateFormat; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/Global.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/Global.java index 7e340b5..57c3acd 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/Global.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/common/Global.java @@ -147,6 +147,7 @@ public class Global { boolean ret = false; synchronized (currentState) { switch (state) { + case INIT: case DONE: currentState = state; ret = true; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/DataThread.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/DataThread.java new file mode 100644 index 0000000..a1ad0fb --- /dev/null +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/DataThread.java @@ -0,0 +1,137 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Jaewon Lim + * Juyoung Kim + * + * 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. + * + * Contributors: + * - S-Core Co., Ltd + * + */ +package org.tizen.dynamicanalyzer.control; + +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; + +import org.tizen.dynamicanalyzer.util.Logger; + +public abstract class DataThread implements Runnable { + + private Thread thread = null; + + private BlockingQueue dataQueue = new LinkedBlockingQueue(); + + protected abstract String getThreadName(); + + protected abstract boolean workAfterStart(); + + protected abstract boolean workAfterStopNormal(); + + protected abstract boolean workAfterStopForced(); + + protected abstract void resetBeforeStart(); // called just before starting thread + + protected abstract void clearAfterStop(); // called just after thread stopped + + protected final void clearQueue() { + synchronized (dataQueue) { + dataQueue.clear(); + } + } + + public synchronized final boolean start() { + if (isThreadAlive()) { + try { + thread.interrupt(); + thread.join(); + thread = null; + } catch (InterruptedException e) { + Logger.exception(e); + return false; + } + } + + clearQueue(); + resetBeforeStart(); + + thread = new Thread(null, this, getThreadName()); + thread.start(); + + return workAfterStart(); + } + + public synchronized final boolean stopNormal() { + if (isThreadAlive()) { + try { + thread.join(); + thread = null; + Logger.debug(getThreadName() + " thread joined!"); //$NON-NLS-1$ + } catch (InterruptedException e) { + Logger.exception(e); + return false; + } + } + + clearQueue(); + clearAfterStop(); + + return workAfterStopNormal(); + } + + public synchronized final boolean stopForced() { + if (isThreadAlive()) { + try { + thread.interrupt(); + thread.join(); + thread = null; + Logger.debug(getThreadName() + " thread joined!"); //$NON-NLS-1$ + } catch (InterruptedException e) { + Logger.exception(e); + return false; + } + } + + clearQueue(); + clearAfterStop(); + + return workAfterStopForced(); + } + + public boolean isThreadAlive() { + return (thread != null && thread.isAlive()); + } + + protected final boolean isSameThread(Thread currentThread) { + return (currentThread == thread); + } + + public final boolean pushData(E data) { + return dataQueue.offer(data); + } + + protected final E pollData() { + E data = null; + try { + data = dataQueue.take(); // wait if empty + } catch (InterruptedException e) { + Logger.debug(getThreadName() + " is interrupted while taking from queue"); + } + + return data; + } +} diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/SideWorker.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/SideWorker.java index 8652dff..40af7b4 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/SideWorker.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/SideWorker.java @@ -60,11 +60,7 @@ public enum SideWorker implements Runnable { public void offerWork(Runnable work) { if (work != null) { - try { - workQueue.put(work); - } catch (InterruptedException e) { - Logger.exception(e); - } + workQueue.offer(work); } } @@ -78,7 +74,7 @@ public enum SideWorker implements Runnable { Logger.debug("expected interrupt exception"); break; } - + if (runnable != null) { runnable.run(); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StartTraceManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StartTraceManager.java index b7454fb..596a98c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StartTraceManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StartTraceManager.java @@ -151,19 +151,27 @@ public class StartTraceManager implements Runnable { setStageComplete(STAGE.RESET_UI); // start data receive thread - result = DataChannelThread.start(); - if (!result.isSuccess()) { + if (!DataChannelThread.getInstance().start()) { // failed to start data channel thread + result = DAResult.ERR_START_DATA_CHANNEL; return; } setStageComplete(STAGE.CREATE_DATATHREAD); // start message parser thread - MessageParser.start(); + if (!MessageParser.getInstance().start()) { + // failed to start message parser + result = DAResult.ERR_START_MESSAGE_PARSER; + return; + } setStageComplete(STAGE.CREATE_MPARSER); // start log parser thread - LogParser.start(); + if (!LogParser.getInstance().start()) { + // failed to start log parser + result = DAResult.ERR_START_LOG_PARSER; + return; + } setStageComplete(STAGE.CREATE_LPARSER); // start registered data manager thread and db inserters @@ -216,7 +224,7 @@ public class StartTraceManager implements Runnable { } catch (InterruptedException e) { // operation is canceled // re-interrupt thread to set the flag as 'interrupted' - Thread.currentThread().interrupt(); +// Thread.currentThread().interrupt(); // set DA state to canceling result = DAResult.ERR_BY_USER_CANCEL; @@ -252,13 +260,13 @@ public class StartTraceManager implements Runnable { DataManagerRegistry.stopThreadsForced(); setCancelProgress(STAGE.CREATE_PAGEMGR); case CREATE_LPARSER: - LogParser.stopForced(); + LogParser.getInstance().stopForced(); setCancelProgress(STAGE.CREATE_LPARSER); case CREATE_MPARSER: - MessageParser.stopForced(); + MessageParser.getInstance().stopForced(); setCancelProgress(STAGE.CREATE_MPARSER); case CREATE_DATATHREAD: - DataChannelThread.stopForced(); + DataChannelThread.getInstance().stopForced(); setCancelProgress(STAGE.CREATE_DATATHREAD); case RESET_UI: case CREATE_DBTABLE: @@ -276,7 +284,7 @@ public class StartTraceManager implements Runnable { } AnalyzerManager.setRunningState(false); - Global.changeCurrentState(STATE.DONE); + Global.changeCurrentState(STATE.INIT); } else { Global.changeCurrentState(STATE.RUNNING); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StopTraceManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StopTraceManager.java index 02685db..7401ff9 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StopTraceManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/control/StopTraceManager.java @@ -103,15 +103,15 @@ public class StopTraceManager implements Runnable { setStageComplete(STAGE.STOP_UPDATE_TIMER); // stop data channel - DataChannelThread.stopNormal(); + DataChannelThread.getInstance().stopNormal(); setStageComplete(STAGE.STOP_DATATHREAD); // stop message parser - MessageParser.stopNormal(); + MessageParser.getInstance().stopNormal(); setStageComplete(STAGE.STOP_MPARSER); // stop log parser - LogParser.stopNormal(); + LogParser.getInstance().stopNormal(); setStageComplete(STAGE.STOP_LPARSER); // stop page data manager diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInserter.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInserter.java index 67da531..41ce0f3 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInserter.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/DBInserter.java @@ -28,97 +28,63 @@ package org.tizen.dynamicanalyzer.database; import java.util.ArrayList; import java.util.List; -import java.util.concurrent.LinkedBlockingQueue; -import org.tizen.dynamicanalyzer.util.Logger; +import org.tizen.dynamicanalyzer.control.DataThread; -public class DBInserter implements Runnable { +public class DBInserter extends DataThread>> { public static List> END_OF_QUEUE = new ArrayList>(); - private LinkedBlockingQueue>> dataQueue = new LinkedBlockingQueue>>(); private DBTable table = null; - private Thread thread = null; public DBInserter(DBTable table) { this.table = table; } - public void start() { - if (thread != null && thread.isAlive()) { - try { - thread.interrupt(); - thread.join(); - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - } - } - - thread = new Thread(this, table.getTableName() + " inserter"); - thread.start(); + @Override + protected String getThreadName() { + return (table.getTableName() + " inserter"); } - public void stopNormal() { - if (thread != null && thread.isAlive()) { - try { - thread.join(); - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - } - } - - clear(); + @Override + protected boolean workAfterStart() { + return true; } - public void stopForced() { - if (thread != null && thread.isAlive()) { - try { - thread.interrupt(); - thread.join(); - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - } - } + @Override + protected boolean workAfterStopNormal() { + return true; + } - clear(); + @Override + protected boolean workAfterStopForced() { + return true; } - public void pushData(List> data) { - dataQueue.offer(data); + @Override + protected void resetBeforeStart() { } - public void clear() { - dataQueue.clear(); + @Override + protected void clearAfterStop() { } @Override public void run() { - while (true) { - List> data; - try { - data = dataQueue.take(); - } catch (InterruptedException e) { - Logger.exception(e); - break; - } + Thread curThread = Thread.currentThread(); - if (data == END_OF_QUEUE) { + while (isSameThread(curThread)) { + List> data = pollData(); + if (data == null || data == END_OF_QUEUE) { break; } - if (data != null && data.size() != 0) { + if (data.size() != 0) { table.insertData(data); } } } public void setToStop() { - try { - dataQueue.put(END_OF_QUEUE); - } catch (InterruptedException e) { - Logger.exception(e); - } + pushData(END_OF_QUEUE); } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/SqlConnectionManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/SqlConnectionManager.java index b67092f..365fc3c 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/SqlConnectionManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/database/SqlConnectionManager.java @@ -50,8 +50,6 @@ public class SqlConnectionManager { private static BlockingQueue queryConnections = null; private static Object updateConnectionLock = new Object(); private static Object queryConnectionLock = new Object(); - private static int realUpdateConnCount = 0; - private static int realQueryConnCount = 0; // DATABASE state private enum State { @@ -68,8 +66,6 @@ public class SqlConnectionManager { if (updateConnections == null && queryConnections == null) { updateConnections = new LinkedBlockingQueue(); queryConnections = new LinkedBlockingQueue(); - realUpdateConnCount = 0; - realQueryConnCount = 0; Class.forName("org.hsqldb.jdbcDriver"); String dbUrl = "jdbc:hsqldb:" + dbFilePath @@ -80,7 +76,6 @@ public class SqlConnectionManager { for (int i = 0; i < CONNECTION_COUNT_UPDATE; i++) { conn = DriverManager.getConnection(dbUrl, "SA", ""); updateConnections.offer(conn); - realUpdateConnCount++; SQLWarning warning = conn.getWarnings(); while (warning != null) { @@ -95,7 +90,6 @@ public class SqlConnectionManager { for (int i = 0; i < CONNECTION_COUNT_QUERY; i++) { conn = DriverManager.getConnection(dbUrl, "SA", ""); queryConnections.offer(conn); - realQueryConnCount++; SQLWarning warning = conn.getWarnings(); while (warning != null) { @@ -133,7 +127,7 @@ public class SqlConnectionManager { if (updateConnections != null) { synchronized (updateConnectionLock) { // wait until other execution is finished - while (updateConnections.size() != realUpdateConnCount) { + while (updateConnections.size() != CONNECTION_COUNT_UPDATE) { try { updateConnectionLock.wait(); } catch (InterruptedException e) { @@ -157,7 +151,7 @@ public class SqlConnectionManager { if (queryConnections != null) { synchronized (queryConnectionLock) { // wait until other execution is finished - while (queryConnections.size() != realQueryConnCount) { + while (queryConnections.size() != CONNECTION_COUNT_QUERY) { try { queryConnectionLock.wait(); } catch (InterruptedException e) { @@ -214,13 +208,9 @@ public class SqlConnectionManager { private static void putUpdateConnection(Connection conn) { if (conn != null) { - try { - synchronized (updateConnectionLock) { - updateConnections.put(conn); - updateConnectionLock.notifyAll(); - } - } catch (InterruptedException e) { - Logger.exception(e); + synchronized (updateConnectionLock) { + updateConnections.offer(conn); + updateConnectionLock.notifyAll(); } } } @@ -240,13 +230,9 @@ public class SqlConnectionManager { private static void putQueryConnection(Connection conn) { if (conn != null) { - try { - synchronized (queryConnectionLock) { - queryConnections.put(conn); - queryConnectionLock.notifyAll(); - } - } catch (InterruptedException e) { - Logger.exception(e); + synchronized (queryConnectionLock) { + queryConnections.offer(conn); + queryConnectionLock.notifyAll(); } } } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ExitHandler.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ExitHandler.java index 29a50d3..d4b9dd2 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ExitHandler.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/handlers/ExitHandler.java @@ -36,9 +36,6 @@ import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.communicator.IDECommunicator; import org.tizen.dynamicanalyzer.control.SideWorker; -import org.tizen.dynamicanalyzer.swap.logparser.LogParser; -import org.tizen.dynamicanalyzer.ui.page.UpdateViewTimer; -import org.tizen.dynamicanalyzer.ui.toolbar.ToolbarArea; public class ExitHandler extends AbstractHandler { @@ -49,9 +46,6 @@ public class ExitHandler extends AbstractHandler { CommandAction.stopTrace(DAResult.SUCCESS, false); AnalyzerManager.setExit(true); - ToolbarArea.getInstance().stopTimer(); - UpdateViewTimer.stop(); - LogParser.stopForced(); SideWorker.stop(); IDECommunicator.stopIDEcommunicatorThread(); CommunicatorUtils.execCommand(AnalyzerShellCommands.DACOMMAND_KILL_MANAGER); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java index 01e0601..443e115 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/Communicator30.java @@ -36,6 +36,7 @@ import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_START_ACK; import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_STOP_ACK; import static org.tizen.dynamicanalyzer.common.AnalyzerConstants.MSG_TARGET_INFO_ACK; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; + import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayOutputStream; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/DataChannelThread.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/DataChannelThread.java index 2cc756d..bb01cde 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/DataChannelThread.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/communicator/DataChannelThread.java @@ -40,6 +40,7 @@ import org.tizen.dynamicanalyzer.common.DALimit; import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.communicator.DACommunicator; +import org.tizen.dynamicanalyzer.control.DataThread; import org.tizen.dynamicanalyzer.control.SideWorker; import org.tizen.dynamicanalyzer.handlers.CommandAction; import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; @@ -48,14 +49,14 @@ import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.swap.model.data.LogDataFactory; import org.tizen.dynamicanalyzer.util.Logger; -public class DataChannelThread implements Runnable { +public class DataChannelThread extends DataThread { + private static final DataChannelThread instance = new DataChannelThread(); + private static final int RECEIVE_BUF_SIZE = 2097152; // 2MB private static final int LOCAL_BUF_SIZE = 1024; - private static Thread mThread = null; - private Object waitObject = new Object(); - boolean throughMode = false; + private boolean throughMode = false; private enum STATE { INITIALIZED, ACTIVATED, TERMINATED; @@ -63,73 +64,54 @@ public class DataChannelThread implements Runnable { private STATE state = STATE.INITIALIZED; - public static DAResult start() { - if (mThread != null && mThread.isAlive()) { - try { - mThread.interrupt(); - mThread.join(); - mThread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_START_DATA_CHANNEL; - } - } + public static DataChannelThread getInstance() { + return instance; + } - DataChannelThread mRunnable = new DataChannelThread(); - mThread = new Thread(null, mRunnable, AnalyzerConstants.COMMUNICATOR_RECEIVE_THREAD); - mThread.start(); + @Override + protected String getThreadName() { + return AnalyzerConstants.COMMUNICATOR_RECEIVE_THREAD; + } - synchronized (mRunnable.waitObject) { + @Override + protected boolean workAfterStart() { + synchronized (waitObject) { try { - if (mRunnable.state == STATE.INITIALIZED) { - mRunnable.waitObject.wait(); + if (state == STATE.INITIALIZED) { + waitObject.wait(); } } catch (InterruptedException e) { Logger.exception(e); } } - if (mRunnable.state == STATE.ACTIVATED) { - return DAResult.SUCCESS; + if (state == STATE.ACTIVATED) { + return true; } else { - return DAResult.ERR_START_DATA_CHANNEL; + return false; } } - public static DAResult stopNormal() { - // do nothing to stop thread - // just wait the thread is terminated by itself - if (mThread != null && mThread.isAlive()) { - // wait until data channel thread is terminated - try { - mThread.join(); // wait forever - mThread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_STOP_DATA_CHANNEL; - } - } - - return DAResult.SUCCESS; + @Override + protected boolean workAfterStopNormal() { + return true; } - public static DAResult stopForced() { - // if thread is not terminated, interrupt it and wait to terminate - if (mThread != null && mThread.isAlive()) { - // wait until data channel thread is terminated - try { - mThread.interrupt(); - mThread.join(); // wait forever - mThread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_STOP_DATA_CHANNEL; - } - } + @Override + protected boolean workAfterStopForced() { + return true; + } + @Override + protected void resetBeforeStart() { + state = STATE.INITIALIZED; + throughMode = false; clearSocketReceiveBuffer(DACommunicator.getDataSocket()); + } - return DAResult.SUCCESS; + @Override + protected void clearAfterStop() { + clearSocketReceiveBuffer(DACommunicator.getDataSocket()); } private void changeToThroughMode() { @@ -171,7 +153,6 @@ public class DataChannelThread implements Runnable { public void run() { try { Socket dataSocket = DACommunicator.getDataSocket(); - clearSocketReceiveBuffer(dataSocket); BufferedInputStream inputStream = null; byte[] header = new byte[DataChannelConstants.HEADER_SIZE]; @@ -190,7 +171,7 @@ public class DataChannelThread implements Runnable { waitObject.notifyAll(); } - while (curThread == mThread) { + while (isSameThread(curThread)) { if (!throughMode) { // read data message header if (!getByte(inputStream, header, DataChannelConstants.HEADER_SIZE)) { @@ -228,10 +209,8 @@ public class DataChannelThread implements Runnable { break; } - try { - MessageParser.pushLog(log); - } catch (InterruptedException e) { - Logger.exception(e); + if (!MessageParser.getInstance().pushData(log)) { + Logger.error("failed to insert log to message parser"); break; } @@ -308,13 +287,7 @@ public class DataChannelThread implements Runnable { } private boolean pushEOQ() { - try { - MessageParser.pushLog(LogData.END_OF_QUEUE); - return true; - } catch (InterruptedException e) { - Logger.exception(e); - return false; - } + return MessageParser.getInstance().pushData(LogData.END_OF_QUEUE); } // return true if last log is arrived diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java index d93aa82..e0d2a8e 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/DataManagerRegistry.java @@ -33,7 +33,7 @@ import java.util.Set; public class DataManagerRegistry { private static Map dataManagers = null; - + static { dataManagers = new HashMap(); } @@ -50,7 +50,7 @@ public class DataManagerRegistry { public static void startThreads() { for (Map.Entry entry : dataManagers.entrySet()) { - entry.getValue().startThread(); + entry.getValue().start(); } } @@ -79,10 +79,10 @@ public class DataManagerRegistry { public static void updateLog(LogPackage pack) { for (Map.Entry entry : dataManagers.entrySet()) { - entry.getValue().updateLog(pack); + entry.getValue().pushData(pack); } } - + public static void saveData() { for (Map.Entry entry : dataManagers.entrySet()) { entry.getValue().saveData(null); diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogParser.java index aca688f..81c3a9b 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/LogParser.java @@ -41,17 +41,15 @@ import java.util.ArrayDeque; import java.util.Deque; import java.util.HashMap; import java.util.Map; -import java.util.concurrent.BlockingQueue; -import java.util.concurrent.LinkedBlockingQueue; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.SymbolManager; import org.tizen.dynamicanalyzer.communicator.CommunicatorUtils; import org.tizen.dynamicanalyzer.communicator.DACommunicator; import org.tizen.dynamicanalyzer.constant.CommonConstants; +import org.tizen.dynamicanalyzer.control.DataThread; import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants; import org.tizen.dynamicanalyzer.swap.model.data.LogData; import org.tizen.dynamicanalyzer.swap.model.data.ProfileData; @@ -63,91 +61,49 @@ import org.tizen.dynamicanalyzer.utils.ImageUtil; import org.tizen.dynamicanalyzer.utils.ImageUtilSWT; import org.tizen.sdblib.service.SyncResult; -public class LogParser implements Runnable { - private static LogParser instance = null; - private static Thread thread = null; +public class LogParser extends DataThread { + private static LogParser instance = new LogParser(); - private BlockingQueue queue = new LinkedBlockingQueue(); + private static final int SMALL_IMG_WIDTH = 40; + private static final int SMALL_IMG_HEIGHT = 66; + + private static final int DEFAULT_IMG_WIDTH = 480; + private static final int DEFAULT_IMG_HEIGHT = 800; // map for matching exit log with entry log private Map> functionEntryStackByTidMap = new HashMap>(); - private int SMALL_IMG_WIDTH = 40; - private int SMALL_IMG_HEIGHT = 66; - - private int DEFAULT_IMG_WIDTH = 480; - private int DEFAULT_IMG_HEIGHT = 800; - - public static DAResult start() { - if (thread != null && thread.isAlive()) { - try { - thread.interrupt(); - thread.join(); - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_START_LOG_PARSER; - } - } - - instance = new LogParser(); - thread = new Thread(null, instance, AnalyzerConstants.LOG_QUEUE_OBSERVING_THREAD); - thread.start(); - - return DAResult.SUCCESS; + public static LogParser getInstance() { + return instance; } - public static DAResult stopNormal() { - // do nothing to stop thread - // just wait the thread is terminated by itself - if (thread != null && thread.isAlive()) { - // wait until data channel thread is terminated - try { - thread.join(); // wait forever - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_START_LOG_PARSER; - } - } - - if (instance != null) { - instance.clear(); - } - instance = null; - - return DAResult.SUCCESS; + @Override + protected String getThreadName() { + return AnalyzerConstants.LOG_QUEUE_OBSERVING_THREAD; } - public static DAResult stopForced() { - if (thread != null && thread.isAlive()) { - // wait until data channel thread is terminated - try { - thread.interrupt(); - thread.join(); // wait forever - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_START_LOG_PARSER; - } - } + @Override + protected boolean workAfterStart() { + return true; + } - if (instance != null) { - instance.clear(); - } - instance = null; + @Override + protected boolean workAfterStopNormal() { + return true; + } - return DAResult.SUCCESS; + @Override + protected boolean workAfterStopForced() { + return true; } - public static void pushLog(LogList loglist) throws InterruptedException { - if (instance != null) { - instance.queue.put(loglist); - } + @Override + protected void resetBeforeStart() { + functionEntryStackByTidMap.clear(); } - private void clear() { - queue.clear(); + @Override + protected void clearAfterStop() { functionEntryStackByTidMap.clear(); } @@ -163,17 +119,13 @@ public class LogParser implements Runnable { /*** log parsing thread ***/ @Override public void run() { + Thread curThread = Thread.currentThread(); + try { LogList loglist; - while (true) { - try { - loglist = queue.take(); - } catch (InterruptedException e) { - Logger.exception(e); - break; - } - - if (loglist == LogList.END_OF_QUEUE) { + while (isSameThread(curThread)) { + loglist = pollData(); + if (loglist == null || loglist == LogList.END_OF_QUEUE) { break; } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java index 83ef47d..20c6314 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/MessageParser.java @@ -33,16 +33,14 @@ import java.io.IOException; import java.io.PrintWriter; import java.util.Timer; import java.util.TimerTask; -import java.util.concurrent.BlockingQueue; -import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import org.tizen.dynamicanalyzer.common.AnalyzerConstants; import org.tizen.dynamicanalyzer.common.AnalyzerManager; -import org.tizen.dynamicanalyzer.common.DAResult; import org.tizen.dynamicanalyzer.common.Global; import org.tizen.dynamicanalyzer.common.path.PathManager; +import org.tizen.dynamicanalyzer.control.DataThread; import org.tizen.dynamicanalyzer.project.BinaryInfo; import org.tizen.dynamicanalyzer.project.LibraryObject; import org.tizen.dynamicanalyzer.project.ProcessInformation; @@ -55,7 +53,9 @@ import org.tizen.dynamicanalyzer.ui.thread.data.ThreadDataManager; import org.tizen.dynamicanalyzer.util.CommonUtil; import org.tizen.dynamicanalyzer.util.Logger; -public class MessageParser implements Runnable { +public class MessageParser extends DataThread { + private static MessageParser instance = new MessageParser(); + private static boolean PRINT_DATA_LOG_TOFILE = false; /* Message Buffer max length */ @@ -63,80 +63,45 @@ public class MessageParser implements Runnable { private static final int MSG_BUFFER_TIMER_DELAY = 5; private static final int MSG_BUFFER_TIMER_PERIOD = 1000; // 1 second - private static Thread thread = null; - private static MessageParser instance = null; - - private BlockingQueue queue = new LinkedBlockingQueue(); - private LogList sendBuffer = new LogList(); private Lock lock = new ReentrantLock(); - private Timer timer = null; - - public static DAResult start() { - if (thread != null && thread.isAlive()) { - try { - thread.interrupt(); - thread.join(); - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_START_MESSAGE_PARSER; - } - } - instance = new MessageParser(); - thread = new Thread(null, instance, AnalyzerConstants.MESSAGE_PARSER_THREAD); - thread.start(); + private LogList sendBuffer = null; + private Timer timer = null; - return DAResult.SUCCESS; + public static MessageParser getInstance() { + return instance; } - public static DAResult stopNormal() { - // do nothing to stop thread - // just wait the thread is terminated by itself - if (thread != null && thread.isAlive()) { - // wait until data channel thread is terminated - try { - thread.join(); // wait forever - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_STOP_MESSAGE_PARSER; - } - } - - if (instance != null) { - instance.clear(); - } - instance = null; + @Override + protected String getThreadName() { + return AnalyzerConstants.MESSAGE_PARSER_THREAD; + } - return DAResult.SUCCESS; + @Override + protected boolean workAfterStart() { + return true; } - public static DAResult stopForced() { - if (thread != null && thread.isAlive()) { - // wait until data channel thread is terminated - try { - thread.interrupt(); - thread.join(); // wait forever - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return DAResult.ERR_STOP_MESSAGE_PARSER; - } - } + @Override + protected boolean workAfterStopNormal() { + return true; + } - if (instance != null) { - instance.clear(); - } - instance = null; + @Override + protected boolean workAfterStopForced() { + return true; + } - return DAResult.SUCCESS; + @Override + protected void resetBeforeStart() { + stopTimer(); + sendBuffer = new LogList(); } - public static void pushLog(LogData data) throws InterruptedException { - if (instance != null) { - instance.queue.put(data); - } + @Override + protected void clearAfterStop() { + stopTimer(); + sendBuffer = null; } private void startTimer() { @@ -161,40 +126,24 @@ public class MessageParser implements Runnable { private void sendDataToLogParser() { lock.lock(); try { - try { - if (null != sendBuffer && 0 != sendBuffer.size()) { - LogParser.pushLog(sendBuffer); - } - - sendBuffer = new LogList(); - } catch (InterruptedException e) { - // do not reset send buffer - Logger.exception(e); + if (null != sendBuffer && 0 != sendBuffer.size()) { + LogParser.getInstance().pushData(sendBuffer); } + + sendBuffer = new LogList(); } finally { lock.unlock(); } } private boolean pushEOQ() { - try { - LogParser.pushLog(LogList.END_OF_QUEUE); - return true; - } catch (InterruptedException e) { - Logger.exception(e); - return false; - } - } - - private void clear() { - stopTimer(); - queue.clear(); - sendBuffer.clear(); + return LogParser.getInstance().pushData(LogList.END_OF_QUEUE); } @Override public void run() { PrintWriter printWriter = getDebugWriter(); + Thread curThread = Thread.currentThread(); try { synchronized (AnalyzerManager.waitStartAck) { @@ -211,15 +160,9 @@ public class MessageParser implements Runnable { startTimer(); LogData log; - while (true) { - try { - log = queue.take(); - } catch (InterruptedException e) { - Logger.exception(e); - break; - } - - if (log == LogData.END_OF_QUEUE) { + while (isSameThread(curThread)) { + log = pollData(); + if (log == null || log == LogData.END_OF_QUEUE) { break; } @@ -379,7 +322,7 @@ public class MessageParser implements Runnable { AnalyzerManager.setProcessInfoArrived(true); - // SEE : what is this ? + // make main thread in thread chart ThreadDataManager.getInstance().getThreadDataMaker().createMainThreadItem(pid); } diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java index 67641c2..d058e39 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/logparser/PageDataManager.java @@ -27,108 +27,55 @@ package org.tizen.dynamicanalyzer.swap.logparser; import java.util.HashMap; import java.util.Map; -import java.util.concurrent.BlockingQueue; -import java.util.concurrent.LinkedBlockingQueue; -import org.tizen.dynamicanalyzer.common.AnalyzerManager; import org.tizen.dynamicanalyzer.constant.CommonConstants; +import org.tizen.dynamicanalyzer.control.DataThread; import org.tizen.dynamicanalyzer.database.DBInserter; import org.tizen.dynamicanalyzer.database.DBTable; -import org.tizen.dynamicanalyzer.util.Logger; -public abstract class PageDataManager implements Runnable { +public abstract class PageDataManager extends DataThread { protected String name = null; - private Thread thread = null; - private BlockingQueue logPackQueue = new LinkedBlockingQueue(); private Map insertThreads = new HashMap(); - public final String getName() { - if (name == null) { - String[] tnames = getClass().getName().split(CommonConstants.CMD_SPLIT_DOT); - name = tnames[tnames.length - 1]; - } - return name; + @Override + protected String getThreadName() { + return getName(); } - public synchronized final void startThread() { - if (thread != null && thread.isAlive()) { - try { - thread.interrupt(); - thread.join(); - thread = null; - } catch (InterruptedException e) { - Logger.exception(e); - return; - } - } - - thread = new Thread(null, this, getName()); - thread.start(); - + @Override + protected boolean workAfterStart() { startInserters(); + return true; } - public synchronized final void stopNormal() { - if (thread != null && thread.isAlive()) { - try { - thread.join(); - thread = null; - Logger.debug(getName() + " thread joined!"); //$NON-NLS-1$ - } catch (InterruptedException e) { - Logger.exception(e); - } - } - - clearQueue(); - + @Override + protected boolean workAfterStopNormal() { stopInsertersNormal(); + return true; } - public synchronized final void stopForced() { - if (thread != null && thread.isAlive()) { - try { - thread.interrupt(); - thread.join(); - thread = null; - Logger.debug(getName() + " thread joined!"); //$NON-NLS-1$ - } catch (InterruptedException e) { - Logger.exception(e); - } - } - - clearQueue(); - + @Override + protected boolean workAfterStopForced() { stopInsertersForced(); - } - - public final boolean isThreadAlive() { - if (null == thread || !thread.isAlive()) { - return false; - } return true; } - public final void updateLog(LogPackage logPack) { - try { - logPackQueue.put(logPack); - } catch (InterruptedException e) { - Logger.exception(e); - } + @Override + protected void resetBeforeStart() { + } - private final LogPackage pollPack() { - LogPackage pack = null; - try { - pack = logPackQueue.take(); // wait if empty - } catch (InterruptedException e) { - Logger.exception(e); - } + @Override + protected void clearAfterStop() { - return pack; } - private final void clearQueue() { - logPackQueue.clear(); + public final String getName() { + if (name == null) { + String[] tnames = getClass().getName().split(CommonConstants.CMD_SPLIT_DOT); + name = tnames[tnames.length - 1]; + } + return name; } public final DBInserter makeInserter(DBTable table) { @@ -179,8 +126,10 @@ public abstract class PageDataManager implements Runnable { @Override public final void run() { - while (!AnalyzerManager.isExit()) { - LogPackage pack = pollPack(); + Thread curThread = Thread.currentThread(); + + while (isSameThread(curThread)) { + LogPackage pack = pollData(); if (pack == null || pack == LogPackage.END_OF_QUEUE) // stop thread break; @@ -190,11 +139,6 @@ public abstract class PageDataManager implements Runnable { onThreadStop(); setToStopInserter(); - - clearQueue(); - - /* log for debug */ - Logger.debug(getName() + " thread end!!"); //$NON-NLS-1$ } public void clear() { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ByteStreamData.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ByteStreamData.java index 2e01455..63b60bd 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ByteStreamData.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/swap/model/data/ByteStreamData.java @@ -26,10 +26,10 @@ */ package org.tizen.dynamicanalyzer.swap.model.data; +import static org.tizen.dynamicanalyzer.constant.CommonConstants.DOUBLE_SIZE; +import static org.tizen.dynamicanalyzer.constant.CommonConstants.FLOAT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.INT_SIZE; import static org.tizen.dynamicanalyzer.constant.CommonConstants.LONG_SIZE; -import static org.tizen.dynamicanalyzer.constant.CommonConstants.FLOAT_SIZE; -import static org.tizen.dynamicanalyzer.constant.CommonConstants.DOUBLE_SIZE; import org.tizen.dynamicanalyzer.constant.CommonConstants; import org.tizen.dynamicanalyzer.util.ByteUtil; diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/UserCustomChart.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/UserCustomChart.java index a54417e..a78e805 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/UserCustomChart.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/timeline/chart/UserCustomChart.java @@ -31,7 +31,6 @@ import java.util.ArrayList; import java.util.List; import org.tizen.dynamicanalyzer.resources.ImageResources; -import org.tizen.dynamicanalyzer.util.Logger; import org.tizen.dynamicanalyzer.widgets.chart.DAChart; import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries; import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard; diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/FeatureDataTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/FeatureDataTest.java index 4c3157a..393c712 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/FeatureDataTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/FeatureDataTest.java @@ -26,7 +26,7 @@ package org.tizen.dynamicanalyzer.ui.toolbar.setting.data; import static java.lang.System.currentTimeMillis; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import java.util.Random; diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/SettingDataManagerTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/SettingDataManagerTest.java index 61bd420..efa41aa 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/SettingDataManagerTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/SettingDataManagerTest.java @@ -25,7 +25,11 @@ */ package org.tizen.dynamicanalyzer.ui.toolbar.setting.data; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import java.util.ArrayList; import java.util.List; diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/TargetDataTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/TargetDataTest.java index 003ba4e..e56625a 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/TargetDataTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/TargetDataTest.java @@ -26,7 +26,10 @@ package org.tizen.dynamicanalyzer.ui.toolbar.setting.data; import static java.lang.System.currentTimeMillis; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import java.util.ArrayList; import java.util.List; diff --git a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/TemplateDataTest.java b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/TemplateDataTest.java index 9a85680..29a60b6 100644 --- a/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/TemplateDataTest.java +++ b/org.tizen.dynamicanalyzer/test/src/org/tizen/dynamicanalyzer/ui/toolbar/setting/data/TemplateDataTest.java @@ -25,7 +25,8 @@ */ package org.tizen.dynamicanalyzer.ui.toolbar.setting.data; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; import java.util.List; -- 2.7.4