We're developing an Eclipse-based RCP. Recently we've updated to Eclipse Juno and currently we focus on quality, which of course brought automated tests into focus, since the application is quite big and the testing effort delays releases.
We're already writing JUnit tests, but I'm more interested in UI tests. With older Eclipses this would not be a problem. There are plenty of good test frameworks around. Unfortunately with Juno everything changed due to the added ability to switch out the default SWT UI by Swing or JavaFX (at least this is what I've understood about the changes causing problems)
So most of the test tools don't work properly anymore. From past experiences it seems that:
SWTBot seems to get not much love lately and is very unstable (can't find elements in certain versions)
Window Tester seems quite good, but has a lot of problems identifying an element during the test run (especially with pop-ups such as content assist or tool tips)
Apparently Froglogics Squish supports Juno, but since a license costs about 2,5k Euro I have to pass
The same seems to be the case for QF-Test (too expensive).
This leaves Jubula (or GUIDancer, which is the commercial Jubula), which we've tried in the past, but which had similar problems as Window Tester and SWTBot (unstable in terms of changes to the Eclipse platform and difficulties to detect some elements)
I need to know, which tool to focus on / trust in. Does anybody have experience with one of the tools or is even currently testing a Juno RCP (or Juno itself for that matter)? Or does anybody know how Eclipse tests their own platform (if they even do it atm)?
Searching for information related to "test", "Juno" and "UI/GUI" only brings up the commercial products.
For me it is important, to find a tool, where I can use the developed test cased even in future releases, which means: A framework project, which has some support of the community to be able to adapt quickly. Also it is important to also find stuff like tool-tips, overlays or content assists/suggestions) - similar to a Selenium compared to basic HTMLUnit.
At this point I don't even care too much about integration, reporting or compliance to standards..
You can find a comprehensive table of GUI-Testing tools in the Eclipse Wiki:
http://wiki.eclipse.org/Automated_Testing#UI_tests
One important decision you have to make is, if you want to use your mouse to record/create tests (Jubula, QFTest, ...), if you want to be able to hand-write test-code (SWTBot, ...), or if you want to be able to do both (WindowTester Pro, ...).
Eclipse Juno is rather new, and I would expect problems with all of the listed tools, however the migration should not take that long since most of these tools mainly focus on testing SWT-widgets and Juno still uses SWT. So far I have not heard from any RCP Application seriously using JavaFX other than for technical demos, but I would be curious to see them!
The problem I think, is rather that testing Eclipse is hard and GUI-testing is especially hard.
You might want to have a look at this study which finds and explains the major problems:
http://swerl.tudelft.nl/twiki/pub/Main/TechnicalReports/TUD-SERG-2011-010.pdf
If you believe this study, JUnit-testing is usually preferable to GUI-testing. Well, with Juno you have the big advantage that Unit-testing Eclipse now is easier than it ever was because the framework switched from inheritance and singletons to dependency injection, which makes it far more testable.
I'd suggest you too look at Xored's Q7, which is used for GUI testing of some of Eclipse projects including Eclipse DLTK, Eclipse LDT, Eclipse Tigerstripe and the tool is just perfect : it let you develop dozens of UI tests per day per engineer, and do not have stability and incorrect-recording problems. It's designed specially and only to test Eclipse-based apps and obviously the best in the niche.
However it costs money, which can be a blocker for you (like squish), but they have a free Community version, which is enough for most of use-cases. As well as those Xored guys just introduced pay-per-testexecution pricing model -- the tools will be free and you have to pay as you go only per tests executed monthly (less than 5000 is free). More about new model is here eclipse-testing.com
Related
I am working on a standalone Eclipse RCP product. My team replaced another team that wrote the infrastructure of the product.
I and my team leader aren't very happy with the Eclipse RCP framework because we feel that it is just very hard to get it to work correctly.
This is because:
The GUI building tools are annoying. XWT is buggy (bindings don't
always work, can't add scrollbars, and this is only the half of it).
SWT also isn't very exciting. I don't like the API and it doesn't
have too many exciting widgets.
Eclipse IDE itself is buggy (we
have to restart it every few hours). We are using eclipse juno. When
we tried to upgrade to luna we ran into some unsolvable issues:
Eclipse Luna: Handlers' #CanExecute methods not called due to wrong context
We have lots of weird bugs (e.g. eclipse looks at wrong selection
service and much more).
Even though there is support and
documentation, we find that it is kind of poor compared to other
solutions out there.
Due to the above, developement of simple
things seem to take too long. We have another .NET product which is
much easier to write.
However, google didn't seem to badmouth eclipse rcp... So I wanted to ask, what do you guys think about it? Do you find it easy to use? Do you find it flexible?
Just want to hear some opinions.
Thanks!!!
Is there any benchmarks or study done comparing these two IDEs in terms of
-- stability
-- developer productivity
-- features
-- performance
-- etc.
I am an Eclipse user (not by choice). Not sure about stability, but performance wise NetBeans is far supperior at least with the lates versions that I worked in; personally, I think NetBeans has enough features to make it a good development environment but I can't tell you for sure, it depends on what is the scope of your task. Overall, eclipse is a good IDE, but NetBeans is just a little better...
Mostly working with eclipse nowadays.
All I can say is M2E is a pain.
With no disrespect intended to the developers of m2e ...
This is the simply the absolute worst plugin for maven. It is slow and it is painful to use.
For big maven projects with more than 70 module components, you can forget about having a quick eclipse evironment.
If you use mvn eclipse:eclipse, the deprecated plugin for configuring eclipse, I believe you are faster with eclipse than with netbeans. Especially when it comes to refactoring.
If instead you use the official m2e plugin ...
Oh my god!
I am answering to this question due to the pure shear pain of waiting for eclipse.
" Invoking CDI Builder" because an #Inject collaborator moved around in the class, triggering a massive build wait time delay... god!
Eclipse! Well... Eclipse is a great IDE for getting started, on small projects, but as projects get enterprise level, and if you use m2e ... oh! you will cry!
And wonder ... how can it be this bad.
Netbeans! Perhaps nota any better in the end.
Last time I used Netbeans, i had two major complaints, that were total deal brekers:
(a) Netbeans was simply awful when dealing with massiven class refactoring.
You change a class name on sub module A, that affects modules B, C and D.
And until you class renaming, move over packages is done, you can go take a coffee, and order a cab.
(b) netbeans had a bug in parsing interfaces, namely there was some sort of regular expression that would take the longest time to run.
So if you can use the old deprecated mvn eclipse:eclipse, you would end up being far better of.
With that said.
The Netbeans debugger compared to the eclipse debugger is light years better.
I prefer the graphics of netbeans and I prefer the simplicity of netbeans.
Just try using the "expressions" where the autocomplete does not work, and you ave to go to "display" to get autcomplete to work and copy it bakc over to expressions!
Eclipse is a patch work, with hundreds of thousands of developers making hundreds of different components of the IDE, leading to an overall result of a total inconsistent product.
Eclipse is a never ending set of settings, just open the preferences and ...
Netbeans, UI is always desing for maximum simplicty.
As I wait for my m2e to finish rebuilding prjects based on whatever whim lead eclipse to start a new build, I start considering again if I should not revisit Netbeans and install the eclipse formatter ...
Eclipse is really in bad shape, In my humble oppinion.
Ther performance of eclipse has to improve 100 fold, especiall eclipse + m2e has to get way way better.
Intelli J - i have never tried.
The best IDE have used so far, is wihout any doubt, Microsfot Visual Code for Javascript and TypeScript.
You use Microsoft Visual Code, and just wonder why eclipse is not like that.
If you are doing Angular Js/Typecipt, simply forget about any other IDE out there. Microsoft Visual Code is the best thing there is, it is fantastic and joy to use.
Blazing fast and light and good looking on every platform of your desire.
But for java + maven, the echo system is a bit lacking on good options.
The man is not supposed to wait for the machine.
A human is always supposed to be slower then a machine ... this is not the case with eclipse m2e, this I can tell you.
The furstration!!!!
Unless you have lots of hardware to throw at it, go with Netbeans.
I have a VM running CentOS 7. At this time, I am only able to allocate 2G ram to the VM, and running Eclipse Oxygen for PHP on it is painfully slow. Netbeans runs just fine in this configuration.
I'm sure some Eclipse devotee would suggest giving the VM more ram which might probably resolve the issue, but unfortunately that is not currently possible.
Another thing that ought to be mentioned is that Eclipse is rather unique in its UI. For example, virtually every editor on the planet uses Ctrl-F to "Find", then function key F3 to "Find Next". Ctrl-G is "Goto line number". Netbeans follows this convention. Eclipse, however, uses Ctrl-K to "Find Next" and Ctrl-L for "Line number".
This won't be an issue if you use Eclipse and nothing else, but if you're like the more typical developer, you use Eclipse when appropriate along with some other tool when appropriate. You will get confused sometimes and use the wrong shortcut. This creates unpredictable problems, particularly if you're unsure what the wrong shortcut just did to your file.
It's not a "performance" issue as per the application, but it slows down the developer. To me, that's just as bad.
Again, some Eclipse devotee might suggest that Eclipse shortcuts can be configured any way you like, which is true, but really, does anybody have that kind of time? Eclipse comes with literally thousands of configuration options, and it's an Internet Search to figure out how to change almost anything.
Netbeans doesn't have thousands of configuration options, although there are things you can tweak. It just sorta mostly works the way you expect out of the box.
To conclude, the actual slowness on less-than-most-super-powerful hardware is probably the biggest thing against Eclipse. I don't know what the code is trying to do, but Netbeans is somehow able to do it with less hardware.
Eclipse and Netbeans are both good IDE (Integrated Development Environment) programs. If you are just a Java, C++, C or Fortran programmer you can use any of them.
If you are WEB base developer (For Example: JSF, Serverlet, Applet) in this case NetBeans is much more powerful then Eclipse.
On the other hand, If you are mobile developer for Android OS, in this case Eclipse is much more powerful then Netbeans.
So it depends on your programming league :)))
I would like to make a new plugin for a programming language because there is not any IDE the time I asked this question. I think IDE developing is far more easier if I try to use one of the available platform like Netbeans or Eclipse or ...
As I checked, Eclipse plugin (if that plugin is not updated) won't be able to start up after 1 or 2 years. I mean, Eclipse develops a way that old plugins has to follow in order to hold the compatibility.
I can't answer your original question as I have not developed for Netbeans.
As the backwards compatibility, if the version dependencies are set right, and only the API from other plug-ins are used, the old plug-in should work (there are some exceptions, but in that case upgrading the plug-in does not take too much effort, as there is documentation about what has changed).
The main drawback in Eclipse development is that documentation is sometimes scarce, but for common tasks there is some available.
Sorry, I also can answer only 1/2 of your question.
I have developed (small) eclipse plugins and an eclipse RCP. Both were a breeze. I agree with #Zoltan's comment, get your dependencies right & don't use some back-door unsupported feature in aplugin you don't control & your problems should be minimal. Even if you did run into a dependency problem, the configuration is straightforward enough that you could make an updated release of your plugin very quickly.
Qt Creator looks like a good IDE. I've been using Eclipse CDT and while a little buggy, it does the job.
Does Qt Creator have the same capabilities as Eclipse CDT?
Qt Creator uses MinGW under the hood, so it only makes sense that it would be able to compile without using any Qt headers. Simply uncheck all of the headers when making the project and you can code just like you would in any other IDE.
I took an example shot for you to see:
Dead link
Edit: Ahh you edited your question.
Yes of course! Qt is a great environment and can sure hold it's own against competitors like Eclipse in C++. Although keep in mind Eclipse satisfies a myriad of developers, from Java to C++ to Python among many others. Typically an IDE specializing in one language will be more catered to that language, but Eclipse sure does one hell of a job catering to developers of multiple languages with it's vast amount of plugins. If you're comfortable with Eclipse CDT, I think you will feel right at home with Qt Creator, better yet, pampered.
such a great piece of software.
Well, QTCreator does exactly what a Linux C++/C dev (i assume you are a linux dev from what i read) would want from an IDE. Neither too much nor too little features. The problem of feature rich IDEs like Eclipse is that you might loose control of your project since it pretty much handles everything. If something goes south you have to take the features/plugins you used into consideration during the debugging process.
But overall, eclipse is (imho) the better choice since it makes sense to get used to one IDE that can pretty much handle every language. At work i use eclipse CDT for exactly this reason. For private projects i use QTCreator, because C/C++ are the only languages i use for these projects.
I hope this helps
Since you mentioned nothing about Qt, I assume that you plan to use QtCreator for a non-Qt C++ project, with its own custom Makefiles, not qmake-based, not Eclipse-CDT-based.
After I switched to QtCreator (now working on the same project, same code) I noticed the following advantages of QtCreator:
QtCreator moves faster than EclipseCDT for the same C/C++ project.
EclipseCDT is harder to config with custom Makefiles. QtCreator is easier. This is the case when you checkout a project with its own custom Makefiles, not IDE-generated ones, and you need to map that project's build targets to EclipseCDT build targets/configurations.
It's easier to deal with .pro(ject) files in QtCreator than workspaces in EclipseCDT.
In my case, the EclipseCDT memory footprint after indexing is about ~2GB. For QtCreator, it is only ~600MB, for the same project.
Source indexing in EclipseCDT takes a lot of time - when I start EclipseCDT, my computer is frozen for about 20 minutes due to indexing. In QtCreator it takes a quarter of that time, and the computer is responsive during it.
Of course there are a lot of advantages that EclipseCDT offers like the plethora of plugins (EGit, Subclipse, cppcheclipse, etc), but it depends if you really use them.
In the end, I think it's a matter of personal taste and habit, as you can achieve your goals with each of them.
I am looking into designing new features for Eclipse-based programming tools, from the requirements/ideas perspective. To really do this quickly, I would like to sketch UI elements without having to code things -- my concern is with the concepts and ideas right now, not the possible later realization. Are there any such graphical sketching tools for Eclipse?
(on a side note, I should also note that I find Eclipse a better idea every day, in the way that you can combine partial systems from very many different sources into a single environment. It really is the future of IDEs, especially for embedded systems. It used to pretty horrible pre-Eclipse-3.0, but now it does seem to work)
WireframeSketcher is a tool that helps quickly create wireframes, mockups and prototypes for desktop, web and mobile applications. It comes both as a standalone version and as a plug-in for Eclipse IDEs. It has some distinctive features like storyboards, components, linking and vector PDF export. Among supported IDEs are are Aptana, Flash Builder, Zend Studio and Rational Application Developer.
(source: wireframesketcher.com)
Incidentally, NetBeans is known for having a really good GUI editor (Matisse), but I realize that you weren't asking about NetBeans :)
I've tried the Visual Editor Project before, but in the past it crashed my instance of Eclipse, and I haven't visited it since.
Jigloo is a new one that I'd like to try out soon.
This is really specific to Eclipse: it is the platform of choice for general IDEs today, and I am looking to sketch out extensions to it. The target programming language is more likely to be raw assembler and C than anything else -- OS, driver, system-level debug.